15 throw std::runtime_error(
"muggH called with a class whose parent is not NPbase");
27 throw std::runtime_error(
"muVBF called with a class whose parent is not NPbase");
40 throw std::runtime_error(
"muVBFgamma called with a class whose parent is not NPbase");
53 throw std::runtime_error(
"mueeWBF called with a class whose parent is not NPbase");
63:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
66 throw std::runtime_error(
"mueeWBFPol called with a class whose parent is not NPbase");
78 throw std::runtime_error(
"mueeHvv called with a class whose parent is not NPbase");
87:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
90 throw std::runtime_error(
"mueeHvvPol called with a class whose parent is not NPbase");
102 throw std::runtime_error(
"mueeZBF called with a class whose parent is not NPbase");
112:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
115 throw std::runtime_error(
"mueeZBFPol called with a class whose parent is not NPbase");
127 throw std::runtime_error(
"muepWBF called with a class whose parent is not NPbase");
140 throw std::runtime_error(
"muWH called with a class whose parent is not NPbase");
152 throw std::runtime_error(
"muWHpT250 called with a class whose parent is not NPbase");
164 throw std::runtime_error(
"muepZBF called with a class whose parent is not NPbase");
177 throw std::runtime_error(
"muZH called with a class whose parent is not NPbase");
189 throw std::runtime_error(
"muZHpT250 called with a class whose parent is not NPbase");
199:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
202 throw std::runtime_error(
"mueeZHGen called with a class whose parent is not NPbase");
212:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
215 throw std::runtime_error(
"mueeZH called with a class whose parent is not NPbase");
227 throw std::runtime_error(
"mueeZllH called with a class whose parent is not NPbase");
236:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
239 throw std::runtime_error(
"mueeZllHPol called with a class whose parent is not NPbase");
251 throw std::runtime_error(
"mueeZqqH called with a class whose parent is not NPbase");
260:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
263 throw std::runtime_error(
"mueeZqqHPol called with a class whose parent is not NPbase");
273:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
276 throw std::runtime_error(
"aPsk called with a class whose parent is not NPbase");
286:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
289 throw std::runtime_error(
"bPsk called with a class whose parent is not NPbase");
302 throw std::runtime_error(
"muVH called with a class whose parent is not NPbase");
314 throw std::runtime_error(
"muVHpT250 called with a class whose parent is not NPbase");
326 throw std::runtime_error(
"muVBFpVH called with a class whose parent is not NPbase");
338 throw std::runtime_error(
"muttH called with a class whose parent is not NPbase");
350 throw std::runtime_error(
"mutHq called with a class whose parent is not NPbase");
362 throw std::runtime_error(
"muggHpttH called with a class whose parent is not NPbase");
374 throw std::runtime_error(
"mueettH called with a class whose parent is not NPbase");
384:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
387 throw std::runtime_error(
"mueettHPol called with a class whose parent is not NPbase");
399 throw std::runtime_error(
"mummH called with a class whose parent is not NPbase");
411 throw std::runtime_error(
"mummHNWA called with a class whose parent is not NPbase");
427 throw std::runtime_error(
"GammaHtoggRatio called with a class whose parent is not NPbase");
439 throw std::runtime_error(
"GammaHtoWWRatio called with a class whose parent is not NPbase");
451 throw std::runtime_error(
"GammaHtoZZRatio called with a class whose parent is not NPbase");
462 throw std::runtime_error(
"GammaHtoZgaRatio called with a class whose parent is not NPbase");
473 throw std::runtime_error(
"GammaHtogagaRatio called with a class whose parent is not NPbase");
484 throw std::runtime_error(
"GammaHtomumuRatio called with a class whose parent is not NPbase");
495 throw std::runtime_error(
"GammaHtotautauRatio called with a class whose parent is not NPbase");
506 throw std::runtime_error(
"GammaHtossRatio called with a class whose parent is not NPbase");
517 throw std::runtime_error(
"GammaHtoccRatio called with a class whose parent is not NPbase");
528 throw std::runtime_error(
"GammaHtobbRatio called with a class whose parent is not NPbase");
540 throw std::runtime_error(
"GammaHRatio called with a class whose parent is not NPbase");
555 throw std::runtime_error(
"BrHtoinvRatio called with a class whose parent is not NPbase");
567 throw std::runtime_error(
"BrHinvisible called with a class whose parent is not NPbase");
579 throw std::runtime_error(
"BrHinvisibleNP called with a class whose parent is not NPbase");
591 throw std::runtime_error(
"BrHexotic called with a class whose parent is not NPbase");
603 throw std::runtime_error(
"BrHtovisRatio called with a class whose parent is not NPbase");
615 throw std::runtime_error(
"BrHtoggRatio called with a class whose parent is not NPbase");
627 throw std::runtime_error(
"BrHtoWWRatio called with a class whose parent is not NPbase");
639 throw std::runtime_error(
"BrHtoZZRatio called with a class whose parent is not NPbase");
651 throw std::runtime_error(
"BrHtoVVRatio called with a class whose parent is not NPbase");
662 throw std::runtime_error(
"BrHtoZgaRatio called with a class whose parent is not NPbase");
673 throw std::runtime_error(
"BrHtoZgallRatio called with a class whose parent is not NPbase");
684 throw std::runtime_error(
"BrHtoZgaeeRatio called with a class whose parent is not NPbase");
695 throw std::runtime_error(
"BrHtoZgamumuRatio called with a class whose parent is not NPbase");
706 throw std::runtime_error(
"BrHtogagaRatio called with a class whose parent is not NPbase");
717 throw std::runtime_error(
"BrHtomumuRatio called with a class whose parent is not NPbase");
728 throw std::runtime_error(
"BrHtotautauRatio called with a class whose parent is not NPbase");
739 throw std::runtime_error(
"BrHtoccRatio called with a class whose parent is not NPbase");
750 throw std::runtime_error(
"BrHtobbRatio called with a class whose parent is not NPbase");
767 throw std::runtime_error(
"BrHto2l2vRatio called with a class whose parent is not NPbase");
780 throw std::runtime_error(
"BrHtoevmuvRatio called with a class whose parent is not NPbase");
793 throw std::runtime_error(
"BrHto2e2vRatio called with a class whose parent is not NPbase");
799 double wH2e2vSM=0.93291e-06, wH2evSM=0.10152e-04;
802 double wH2e2vTSM=wH2e2vSM+wH2evSM;
812 throw std::runtime_error(
"BrHto2mu2vRatio called with a class whose parent is not NPbase");
818 double wH2mu2vSM=0.93288e-06, wH2muvSM=0.10163e-04;
821 double wH2mu2vTSM=wH2mu2vSM+wH2muvSM;
831 throw std::runtime_error(
"BrHto4lRatio called with a class whose parent is not NPbase");
844 throw std::runtime_error(
"BrHto4eRatio called with a class whose parent is not NPbase");
857 throw std::runtime_error(
"BrHto4muRatio called with a class whose parent is not NPbase");
870 throw std::runtime_error(
"BrHto2e2muRatio called with a class whose parent is not NPbase");
884 throw std::runtime_error(
"BrHtolljjRatio called with a class whose parent is not NPbase");
897 throw std::runtime_error(
"BrHtolvjjRatio called with a class whose parent is not NPbase");
910 throw std::runtime_error(
"BrHtolv_lvorjjRatio called with a class whose parent is not NPbase");
923 throw std::runtime_error(
"BrHtoll_vvorjjRatio called with a class whose parent is not NPbase");
938 throw std::runtime_error(
"BrHtogaga_over_mumu_Ratio called with a class whose parent is not NPbase");
943 if ((this->
getModel()).isModelLinearized()) {
953 throw std::runtime_error(
"BrHtoZga_over_mumu_Ratio called with a class whose parent is not NPbase");
958 if ((this->
getModel()).isModelLinearized()) {
968 throw std::runtime_error(
"BrHtoZmumuga_over_mumu_Ratio called with a class whose parent is not NPbase");
973 if ((this->
getModel()).isModelLinearized()) {
983 throw std::runtime_error(
"BrHtoZga_over_4mu_Ratio called with a class whose parent is not NPbase");
988 if ((this->
getModel()).isModelLinearized()) {
998 throw std::runtime_error(
"BrHtoZmumuga_over_4mu_Ratio called with a class whose parent is not NPbase");
1003 if ((this->
getModel()).isModelLinearized()) {
1013 throw std::runtime_error(
"BrHtogaga_over_4l_Ratio called with a class whose parent is not NPbase");
1018 if ((this->
getModel()).isModelLinearized()) {
1028 throw std::runtime_error(
"BrHtobb_over_4l_Ratio called with a class whose parent is not NPbase");
1033 if ((this->
getModel()).isModelLinearized()) {
1044 throw std::runtime_error(
"BrHto2l2v_over_4l_Ratio called with a class whose parent is not NPbase");
1049 if ((this->
getModel()).isModelLinearized()) {
1060 throw std::runtime_error(
"BrHtotautau_over_4l_Ratio called with a class whose parent is not NPbase");
1065 if ((this->
getModel()).isModelLinearized()) {
1076 throw std::runtime_error(
"BrHtogaga_over_2e2mu_Ratio called with a class whose parent is not NPbase");
1081 if ((this->
getModel()).isModelLinearized()) {
1091 throw std::runtime_error(
"BrHtoZga_over_4l_Ratio called with a class whose parent is not NPbase");
1096 if ((this->
getModel()).isModelLinearized()) {
1106 throw std::runtime_error(
"BrHtomumu_over_4l_Ratio called with a class whose parent is not NPbase");
1111 if ((this->
getModel()).isModelLinearized()) {
1121 throw std::runtime_error(
"BrHtomumu_over_4mu_Ratio called with a class whose parent is not NPbase");
1126 if ((this->
getModel()).isModelLinearized()) {
1136 throw std::runtime_error(
"BrHto4l_over_gaga_Ratio called with a class whose parent is not NPbase");
1141 if ((this->
getModel()).isModelLinearized()) {
1151 throw std::runtime_error(
"BrHtoZga_over_gaga_Ratio called with a class whose parent is not NPbase");
1156 if ((this->
getModel()).isModelLinearized()) {
1166 throw std::runtime_error(
"BrHtomumu_over_gaga_Ratio called with a class whose parent is not NPbase");
1171 if ((this->
getModel()).isModelLinearized()) {
1182 throw std::runtime_error(
"BrHto2l2v_over_gaga_Ratio called with a class whose parent is not NPbase");
1187 if ((this->
getModel()).isModelLinearized()) {
1198 throw std::runtime_error(
"BrHtobb_over_cc_Ratio called with a class whose parent is not NPbase");
1203 if ((this->
getModel()).isModelLinearized()) {
1214 throw std::runtime_error(
"BrHtogaga_over_gg_Ratio called with a class whose parent is not NPbase");
1219 if ((this->
getModel()).isModelLinearized()) {
1230 throw std::runtime_error(
"BrHtogg_over_bb_Ratio called with a class whose parent is not NPbase");
1235 if ((this->
getModel()).isModelLinearized()) {
1246 throw std::runtime_error(
"BrHtogg_over_cc_Ratio called with a class whose parent is not NPbase");
1251 if ((this->
getModel()).isModelLinearized()) {
1267 throw std::runtime_error(
"muggHgaga called with a class whose parent is not NPbase");
1272 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1283 double Br1 = dGammaR1-dGammaRTot1;
1284 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1285 return ( 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1) );
1295 throw std::runtime_error(
"muggHgagaInt called with a class whose parent is not NPbase");
1307 throw std::runtime_error(
"muVBFHgaga called with a class whose parent is not NPbase");
1312 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1323 double Br1 = dGammaR1-dGammaRTot1;
1324 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1328 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1330 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1342 throw std::runtime_error(
"muZHgaga called with a class whose parent is not NPbase");
1347 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1358 double Br1 = dGammaR1-dGammaRTot1;
1359 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1363 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1365 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1378 throw std::runtime_error(
"muWHgaga called with a class whose parent is not NPbase");
1383 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1394 double Br1 = dGammaR1-dGammaRTot1;
1395 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1399 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1401 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1414 throw std::runtime_error(
"muVHgaga called with a class whose parent is not NPbase");
1419 if ((this->
getModel()).isModelLinearized()) {
1430 throw std::runtime_error(
"muttHgaga called with a class whose parent is not NPbase");
1435 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1446 double Br1 = dGammaR1-dGammaRTot1;
1447 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1451 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1453 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1466 throw std::runtime_error(
"mutHgaga called with a class whose parent is not NPbase");
1471 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1481 double Br1 = dGammaR1-dGammaRTot1;
1482 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1486 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1488 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1496 if(NPmutHgaga==1.0){
1508 throw std::runtime_error(
"muggHpbbH_Hgaga called with a class whose parent is not NPbase");
1513 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1523 double Br1 = dGammaR1-dGammaRTot1;
1524 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1528 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1530 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1540 if (NPmuggHpbbH_Hgaga == 1.0){
1543 return NPmuggHpbbH_Hgaga;
1552 throw std::runtime_error(
"muttHptH_Hgaga called with a class whose parent is not NPbase");
1562 double xsSM_ttH = 0.499873;
1563 double xsSM_tH = 0.0821;
1567 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1577 double Br1 = dGammaR1-dGammaRTot1;
1578 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1582 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1584 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1592 if(NPmuttHptH_Hgaga==1.0){
1595 return NPmuttHptH_Hgaga;
1604 throw std::runtime_error(
"muggHZga called with a class whose parent is not NPbase");
1609 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1620 double Br1 = dGammaR1-dGammaRTot1;
1621 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1625 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1627 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1640 throw std::runtime_error(
"muggHZgamumu called with a class whose parent is not NPbase");
1645 if ((this->
getModel()).isModelLinearized()) {
1656 throw std::runtime_error(
"muVBFHZga called with a class whose parent is not NPbase");
1661 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1672 double Br1 = dGammaR1-dGammaRTot1;
1673 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1677 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1679 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1692 throw std::runtime_error(
"muZHZga called with a class whose parent is not NPbase");
1697 if ((this->
getModel()).isModelLinearized()) {
1708 throw std::runtime_error(
"muWHZga called with a class whose parent is not NPbase");
1713 if ((this->
getModel()).isModelLinearized()) {
1724 throw std::runtime_error(
"muVHZga called with a class whose parent is not NPbase");
1729 if ((this->
getModel()).isModelLinearized()) {
1740 throw std::runtime_error(
"muttHZga called with a class whose parent is not NPbase");
1745 if ((this->
getModel()).isModelLinearized()) {
1760 throw std::runtime_error(
"muggHpttHptHpbbH_HZga called with a class whose parent is not NPbase");
1774 double xsSM_ggHbbH = 44.745;
1775 double xsSM_ttH = 0.4998;
1776 double xsSM_tH = 0.084769;
1784 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1794 double Br1 = dGammaR1-dGammaRTot1;
1795 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1799 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1801 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1812 if(NPmuggHpttHptHpbbH_HZga==1.0){
1815 return NPmuggHpttHptHpbbH_HZga;
1825 throw std::runtime_error(
"muVBFpVH_HZga called with a class whose parent is not NPbase");
1836 double xsSM_VBF = 3.49948;
1837 double xsSM_WH = 1.21539;
1838 double xsSM_ZH = 0.795910;
1842 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1852 double Br1 = dGammaR1-dGammaRTot1;
1853 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1857 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1859 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1868 if(NPmuVBFpVH_HZga==1.0){
1871 return NPmuVBFpVH_HZga;
1885 throw std::runtime_error(
"muggHZZ called with a class whose parent is not NPbase");
1890 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1901 double Br1 = dGammaR1-dGammaRTot1;
1902 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1906 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1908 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1921 throw std::runtime_error(
"muVBFHZZ called with a class whose parent is not NPbase");
1926 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1937 double Br1 = dGammaR1-dGammaRTot1;
1938 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1942 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1944 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1957 throw std::runtime_error(
"muZHZZ called with a class whose parent is not NPbase");
1962 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
1973 double Br1 = dGammaR1-dGammaRTot1;
1974 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
1978 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
1980 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
1993 throw std::runtime_error(
"muWHZZ called with a class whose parent is not NPbase");
1998 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2009 double Br1 = dGammaR1-dGammaRTot1;
2010 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2014 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2016 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2029 throw std::runtime_error(
"muVHZZ called with a class whose parent is not NPbase");
2039 double xsSM_WH = 1.21539;
2040 double xsSM_ZH = 0.795910;
2043 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2054 double Br1 = dGammaR1-dGammaRTot1;
2055 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2059 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2061 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2082 throw std::runtime_error(
"muttHZZ called with a class whose parent is not NPbase");
2087 if ((this->
getModel()).isModelLinearized()) {
2098 throw std::runtime_error(
"muttHptH_HZZ called with a class whose parent is not NPbase");
2108 double xsSM_ttH = 0.499873;
2109 double xsSM_tH = 0.0821;
2112 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2123 double Br1 = dGammaR1-dGammaRTot1;
2124 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2128 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2130 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2139 if(NPmuttHptH_HZZ==1.0){
2142 return NPmuttHptH_HZZ;
2151 throw std::runtime_error(
"muttHptH_Hmumu called with a class whose parent is not NPbase");
2161 double xsSM_ttH = 0.499873;
2162 double xsSM_tH = 0.0821;
2165 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2176 double Br1 = dGammaR1-dGammaRTot1;
2177 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2181 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2183 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2192 if(NPmuttHptH_Hmumu==1.0){
2195 return NPmuttHptH_Hmumu;
2204 throw std::runtime_error(
"muggHpbbH_HZZ called with a class whose parent is not NPbase");
2209 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2220 double Br1 = dGammaR1-dGammaRTot1;
2221 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2225 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2227 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2237 if (NPmuggHpbbH_HZZ == 1.0){
2240 return NPmuggHpbbH_HZZ;
2249 throw std::runtime_error(
"muggHZZ4l called with a class whose parent is not NPbase");
2254 if ((this->
getModel()).isModelLinearized()) {
2265 throw std::runtime_error(
"muggHZZ4mu called with a class whose parent is not NPbase");
2270 if ((this->
getModel()).isModelLinearized()) {
2281 throw std::runtime_error(
"muVBFHZZ4l called with a class whose parent is not NPbase");
2286 if ((this->
getModel()).isModelLinearized()) {
2297 throw std::runtime_error(
"muZHZZ4l called with a class whose parent is not NPbase");
2302 if ((this->
getModel()).isModelLinearized()) {
2313 throw std::runtime_error(
"muWHZZ4l called with a class whose parent is not NPbase");
2318 if ((this->
getModel()).isModelLinearized()) {
2329 throw std::runtime_error(
"muVHZZ4l called with a class whose parent is not NPbase");
2334 if ((this->
getModel()).isModelLinearized()) {
2345 throw std::runtime_error(
"muttHZZ4l called with a class whose parent is not NPbase");
2350 if ((this->
getModel()).isModelLinearized()) {
2361 throw std::runtime_error(
"muggHWW called with a class whose parent is not NPbase");
2366 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2377 double Br1 = dGammaR1-dGammaRTot1;
2378 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2382 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2384 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2397 throw std::runtime_error(
"muVBFHWW called with a class whose parent is not NPbase");
2402 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2413 double Br1 = dGammaR1-dGammaRTot1;
2414 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2418 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2420 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2433 throw std::runtime_error(
"muZHWW called with a class whose parent is not NPbase");
2438 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2449 double Br1 = dGammaR1-dGammaRTot1;
2450 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2454 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2456 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2469 throw std::runtime_error(
"muWHWW called with a class whose parent is not NPbase");
2474 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2485 double Br1 = dGammaR1-dGammaRTot1;
2486 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2490 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2492 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2505 throw std::runtime_error(
"muVHWW called with a class whose parent is not NPbase");
2510 if ((this->
getModel()).isModelLinearized()) {
2521 throw std::runtime_error(
"muttHWW called with a class whose parent is not NPbase");
2526 if ((this->
getModel()).isModelLinearized()) {
2537 throw std::runtime_error(
"muttHptH_HWW called with a class whose parent is not NPbase");
2548 double xsSM_ttH = 0.499873;
2549 double xsSM_tH = 0.0821;
2552 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2562 double Br1 = dGammaR1-dGammaRTot1;
2563 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2567 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2569 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2578 if(NPmuttHptH_HWW==1.0){
2581 return NPmuttHptH_HWW;
2590 throw std::runtime_error(
"muggHpbbH_HWW called with a class whose parent is not NPbase");
2595 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2606 double Br1 = dGammaR1-dGammaRTot1;
2607 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2611 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2613 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2624 if (NPmuggHpbbH_HWW == 1.0){
2627 return NPmuggHpbbH_HWW;
2636 throw std::runtime_error(
"muggHWW2l2v called with a class whose parent is not NPbase");
2641 if ((this->
getModel()).isModelLinearized()) {
2652 throw std::runtime_error(
"muVBFHWW2l2v called with a class whose parent is not NPbase");
2657 if ((this->
getModel()).isModelLinearized()) {
2668 throw std::runtime_error(
"muZHWW2l2v called with a class whose parent is not NPbase");
2673 if ((this->
getModel()).isModelLinearized()) {
2684 throw std::runtime_error(
"muWHWW2l2v called with a class whose parent is not NPbase");
2689 if ((this->
getModel()).isModelLinearized()) {
2700 throw std::runtime_error(
"muVHWW2l2v called with a class whose parent is not NPbase");
2705 if ((this->
getModel()).isModelLinearized()) {
2716 throw std::runtime_error(
"muttHWW2l2v called with a class whose parent is not NPbase");
2721 if ((this->
getModel()).isModelLinearized()) {
2732 throw std::runtime_error(
"muttHVV called with a class whose parent is not NPbase");
2737 if ((this->
getModel()).isModelLinearized()) {
2748 throw std::runtime_error(
"muggHmumu called with a class whose parent is not NPbase");
2753 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2764 double Br1 = dGammaR1-dGammaRTot1;
2765 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2769 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2771 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2784 throw std::runtime_error(
"muVBFHmumu called with a class whose parent is not NPbase");
2789 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2800 double Br1 = dGammaR1-dGammaRTot1;
2801 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2805 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2807 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2820 throw std::runtime_error(
"muZHmumu called with a class whose parent is not NPbase");
2825 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2835 double Br1 = dGammaR1-dGammaRTot1;
2836 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2840 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2842 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2855 throw std::runtime_error(
"muWHmumu called with a class whose parent is not NPbase");
2860 if ((this->
getModel()).isModelLinearized()) {
2871 throw std::runtime_error(
"muVHmumu called with a class whose parent is not NPbase");
2882 double xsSM_WH = 1.21539;
2883 double xsSM_ZH = 0.795910;
2886 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2897 double Br1 = dGammaR1-dGammaRTot1;
2898 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2902 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2904 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2913 if(NPmuVHmumu==1.0){
2926 throw std::runtime_error(
"muttHmumu called with a class whose parent is not NPbase");
2931 if ((this->
getModel()).isModelLinearized()) {
2942 throw std::runtime_error(
"muggHpttHptHpbbH_Hmumu called with a class whose parent is not NPbase");
2956 double xsSM_ggHbbH = 44.745;
2957 double xsSM_ttH = 0.4998;
2958 double xsSM_tH = 0.084769;
2966 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
2976 double Br1 = dGammaR1-dGammaRTot1;
2977 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
2981 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
2983 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
2994 if(NPmuggHpttHptHpbbH_Hmumu==1.0){
2997 return NPmuggHpttHptHpbbH_Hmumu;
3006 throw std::runtime_error(
"muVBFpVH_Hmumu called with a class whose parent is not NPbase");
3017 double xsSM_VBF = 3.49948;
3018 double xsSM_WH = 1.21539;
3019 double xsSM_ZH = 0.795910;
3023 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3033 double Br1 = dGammaR1-dGammaRTot1;
3034 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3038 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3040 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3049 if(NPmuVBFpVH_Hmumu==1.0){
3052 return NPmuVBFpVH_Hmumu;
3061 throw std::runtime_error(
"muggHtautau called with a class whose parent is not NPbase");
3066 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3077 double Br1 = dGammaR1-dGammaRTot1;
3078 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3082 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3084 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3097 throw std::runtime_error(
"muVBFHtautau called with a class whose parent is not NPbase");
3102 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3113 double Br1 = dGammaR1-dGammaRTot1;
3114 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3118 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3120 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3135 throw std::runtime_error(
"muVBFpVHtautau called with a class whose parent is not NPbase");
3140 if ((this->
getModel()).isModelLinearized()) {
3152 throw std::runtime_error(
"muZHtautau called with a class whose parent is not NPbase");
3157 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3169 double Br1 = dGammaR1-dGammaRTot1;
3170 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3174 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3176 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3189 throw std::runtime_error(
"muWHtautau called with a class whose parent is not NPbase");
3194 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3205 double Br1 = dGammaR1-dGammaRTot1;
3206 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3220 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3222 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3235 throw std::runtime_error(
"muVHtautau called with a class whose parent is not NPbase");
3245 double xsSM_WH = 1.21539;
3246 double xsSM_ZH = 0.795910;
3249 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3260 double Br1 = dGammaR1-dGammaRTot1;
3261 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3265 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3267 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3277 if(NPmuVHtautau==1.0){
3280 return NPmuVHtautau;
3289 throw std::runtime_error(
"muttHtautau called with a class whose parent is not NPbase");
3294 if ((this->
getModel()).isModelLinearized()) {
3305 throw std::runtime_error(
"muttHptH_Htautau called with a class whose parent is not NPbase");
3315 double xsSM_ttH = 0.499873;
3316 double xsSM_tH = 0.0821;
3319 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3329 double Br1 = dGammaR1-dGammaRTot1;
3330 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3334 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3336 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3345 if(NPmuttHptH_Htautau==1.0){
3348 return NPmuttHptH_Htautau;
3358 throw std::runtime_error(
"muggHpbbH_Htautau called with a class whose parent is not NPbase");
3363 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3374 double Br1 = dGammaR1-dGammaRTot1;
3375 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3379 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3381 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3392 if (NPmuggHpbbH_Htautau == 1.0){
3395 return NPmuggHpbbH_Htautau;
3404 throw std::runtime_error(
"muggHbb called with a class whose parent is not NPbase");
3409 if ((this->
getModel()).isModelLinearized()) {
3420 double Br1 = dGammaR1-dGammaRTot1;
3421 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3425 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3427 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3440 throw std::runtime_error(
"muVBFHbb called with a class whose parent is not NPbase");
3445 if ((this->
getModel()).isModelLinearized()) {
3456 throw std::runtime_error(
"muZHbb called with a class whose parent is not NPbase");
3461 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3472 double Br1 = dGammaR1-dGammaRTot1;
3473 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3477 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3479 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3492 throw std::runtime_error(
"muWHbb called with a class whose parent is not NPbase");
3497 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3508 double Br1 = dGammaR1-dGammaRTot1;
3509 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3513 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3515 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3528 throw std::runtime_error(
"muVHbb called with a class whose parent is not NPbase");
3533 if ((this->
getModel()).isModelLinearized()) {
3544 throw std::runtime_error(
"muttHbb called with a class whose parent is not NPbase");
3549 if ((this->
getModel()).isModelLinearized()) {
3560 throw std::runtime_error(
"muttHptH_Hbb called with a class whose parent is not NPbase");
3570 double xsSM_ttH = 0.499873;
3571 double xsSM_tH = 0.0821;
3574 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3584 double Br1 = dGammaR1-dGammaRTot1;
3585 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3589 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3591 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3601 if(NPmuttHptH_Hbb==1.0){
3604 return NPmuttHptH_Hbb;
3613 throw std::runtime_error(
"muggHpVBFpbbH_Hbb called with a class whose parent is not NPbase");
3627 double xsSM_ggHbbH = 44.745;
3628 double xsSM_VBF = 3.49948;
3632 if ((this->
getModel()).isModelLinearized() || (this->
getModel()).isModelNPquadratic()) {
3642 double Br1 = dGammaR1-dGammaRTot1;
3643 double Br2 = dGammaR2 -dGammaRTot2 - dGammaR1*dGammaRTot1 + pow(dGammaRTot1,2.0);
3647 mu = 1.0 + (muProd1 + Br1) + (muProd2 + Br2 + muProd1*Br1);
3649 if (mu < 0)
return std::numeric_limits<double>::quiet_NaN();
3661 if(NPmuggHpVBFpbbH_Hbb==1.0){
3664 return NPmuggHpVBFpbbH_Hbb;
3675 throw std::runtime_error(
"muVHbb called with a class whose parent is not NPbase");
3680 if ((this->
getModel()).isModelLinearized()) {
3692 throw std::runtime_error(
"muVBFBRinv called with a class whose parent is not NPbase");
3706 throw std::runtime_error(
"muVBFHinv called with a class whose parent is not NPbase");
3712 if ((this->
getModel()).isModelLinearized()) {
3725 throw std::runtime_error(
"muVHBRinv called with a class whose parent is not NPbase");
3739 throw std::runtime_error(
"muVHinv called with a class whose parent is not NPbase");
3745 if ((this->
getModel()).isModelLinearized()) {
3758 throw std::runtime_error(
"muppHmumu called with a class whose parent is not NPbase");
3770 throw std::runtime_error(
"muppHZga called with a class whose parent is not NPbase");
3782 throw std::runtime_error(
"muggH called with a class whose parent is not NPbase");
3787 if ((this->
getModel()).isModelLinearized()) {
3798 throw std::runtime_error(
"muttHZbbboost called with a class whose parent is not NPbase");
3810 throw std::runtime_error(
"muttHgagaZeeboost called with a class whose parent is not NPbase");
3823 throw std::runtime_error(
"ggHgaga called with a class whose parent is not NPbase");
3827 double SM_prediction = 0.0439;
3828 if ((this->
getModel()).isModelLinearized()) {
3840 throw std::runtime_error(
"ggHZZ called with a class whose parent is not NPbase");
3844 double SM_prediction = 0.5197;
3845 if ((this->
getModel()).isModelLinearized()) {
3857 throw std::runtime_error(
"ggHWW called with a class whose parent is not NPbase");
3861 double SM_prediction = 4.1603;
3862 if ((this->
getModel()).isModelLinearized()) {
3874 throw std::runtime_error(
"ggHtautau called with a class whose parent is not NPbase");
3878 double SM_prediction = 1.2215;
3879 if ((this->
getModel()).isModelLinearized()) {
3891 throw std::runtime_error(
"VBFHgaga called with a class whose parent is not NPbase");
3895 double SM_prediction = 0.0037;
3896 if ((this->
getModel()).isModelLinearized()) {
3908 throw std::runtime_error(
"VBFHZZ called with a class whose parent is not NPbase");
3912 double SM_prediction = 0.0530;
3913 if ((this->
getModel()).isModelLinearized()) {
3925 throw std::runtime_error(
"VBFHWW called with a class whose parent is not NPbase");
3929 double SM_prediction = 0.3494;
3930 if ((this->
getModel()).isModelLinearized()) {
3942 throw std::runtime_error(
"VBFHtautau called with a class whose parent is not NPbase");
3946 double SM_prediction = 0.1011;
3947 if ((this->
getModel()).isModelLinearized()) {
3959 throw std::runtime_error(
"WHgaga called with a class whose parent is not NPbase");
3963 double SM_prediction = 0.0017;
3964 if ((this->
getModel()).isModelLinearized()) {
3976 throw std::runtime_error(
"WHWW called with a class whose parent is not NPbase");
3980 double SM_prediction = 0.1614;
3981 if ((this->
getModel()).isModelLinearized()) {
3993 throw std::runtime_error(
"WWHtautau called with a class whose parent is not NPbase");
3997 double SM_prediction = 0.0462;
3998 if ((this->
getModel()).isModelLinearized()) {
4010 throw std::runtime_error(
"WHbb called with a class whose parent is not NPbase");
4014 double SM_prediction = 0.4090;
4015 if ((this->
getModel()).isModelLinearized()) {
4027 throw std::runtime_error(
"ZHgaga called with a class whose parent is not NPbase");
4031 double SM_prediction = 0.0011;
4032 if ((this->
getModel()).isModelLinearized()) {
4044 throw std::runtime_error(
"ZHWW called with a class whose parent is not NPbase");
4048 double SM_prediction = 0.0996;
4049 if ((this->
getModel()).isModelLinearized()) {
4061 throw std::runtime_error(
"ZHtautau called with a class whose parent is not NPbase");
4065 double SM_prediction = 0.0304;
4066 if ((this->
getModel()).isModelLinearized()) {
4078 throw std::runtime_error(
"ZHbb called with a class whose parent is not NPbase");
4082 double SM_prediction = 0.2410;
4083 if ((this->
getModel()).isModelLinearized()) {
4095 throw std::runtime_error(
"ttHgaga called with a class whose parent is not NPbase");
4099 double SM_prediction = 0.0004;
4100 if ((this->
getModel()).isModelLinearized()) {
4112 throw std::runtime_error(
"ttHWW called with a class whose parent is not NPbase");
4116 double SM_prediction = 0.0281;
4117 if ((this->
getModel()).isModelLinearized()) {
4129 throw std::runtime_error(
"ttHtautau called with a class whose parent is not NPbase");
4133 double SM_prediction = 0.0106;
4134 if ((this->
getModel()).isModelLinearized()) {
4146 throw std::runtime_error(
"ttHbb called with a class whose parent is not NPbase");
4150 double SM_prediction = 0.0751;
4151 if ((this->
getModel()).isModelLinearized()) {
4163 throw std::runtime_error(
"UpperLimit_ppHZgammaA called with a class whose parent is not NPbase");
4174 throw std::runtime_error(
"UpperLimit_ppHZgammaA13 called with a class whose parent is not NPbase");
4185 throw std::runtime_error(
"UpperLimit_ppHZgammaC13 called with a class whose parent is not NPbase");
4196 throw std::runtime_error(
"UpperLimit_ppHZgammaC called with a class whose parent is not NPbase");
4207 throw std::runtime_error(
"cg_plus_ct called with a class whose parent is not NPbase");
4218 throw std::runtime_error(
"cga_plus_ct called with a class whose parent is not NPbase");
4229 throw std::runtime_error(
"cg_minus_cga called with a class whose parent is not NPbase");
4240 throw std::runtime_error(
"cV_plus_cb called with a class whose parent is not NPbase");
4253 throw std::runtime_error(
"cV_plus_ctau called with a class whose parent is not NPbase");
4264 throw std::runtime_error(
"cb_minus_cc called with a class whose parent is not NPbase");
4275 throw std::runtime_error(
"cb_minus_ctau called with a class whose parent is not NPbase");
4286 throw std::runtime_error(
"cc_minus_ctau called with a class whose parent is not NPbase");
4299:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4302 throw std::runtime_error(
"mueeZHbb called with a class whose parent is not NPbase");
4307 if ((this->
getModel()).isModelLinearized()) {
4315:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4318 throw std::runtime_error(
"mueeZHcc called with a class whose parent is not NPbase");
4323 if ((this->
getModel()).isModelLinearized()) {
4331:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4334 throw std::runtime_error(
"mueeZHss called with a class whose parent is not NPbase");
4339 if ((this->
getModel()).isModelLinearized()) {
4347:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4350 throw std::runtime_error(
"mueeZHgg called with a class whose parent is not NPbase");
4355 if ((this->
getModel()).isModelLinearized()) {
4363:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4366 throw std::runtime_error(
"mueeZHWW called with a class whose parent is not NPbase");
4371 if ((this->
getModel()).isModelLinearized()) {
4379:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4382 throw std::runtime_error(
"mueeZHtautau called with a class whose parent is not NPbase");
4387 if ((this->
getModel()).isModelLinearized()) {
4395:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4398 throw std::runtime_error(
"mueeZHZZ called with a class whose parent is not NPbase");
4403 if ((this->
getModel()).isModelLinearized()) {
4411:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4414 throw std::runtime_error(
"mueeZHZga called with a class whose parent is not NPbase");
4419 if ((this->
getModel()).isModelLinearized()) {
4427:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4430 throw std::runtime_error(
"mueeZHgaga called with a class whose parent is not NPbase");
4435 if ((this->
getModel()).isModelLinearized()) {
4443:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4446 throw std::runtime_error(
"mueeZHmumu called with a class whose parent is not NPbase");
4451 if ((this->
getModel()).isModelLinearized()) {
4459:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4462 throw std::runtime_error(
"mueeZHBRinv called with a class whose parent is not NPbase");
4473:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4476 throw std::runtime_error(
"mueeZHinv called with a class whose parent is not NPbase");
4482 if ((this->
getModel()).isModelLinearized()) {
4494 throw std::runtime_error(
"mueeWBFbb called with a class whose parent is not NPbase");
4500 if ((this->
getModel()).isModelLinearized()) {
4508:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4511 throw std::runtime_error(
"mueeWBFbbPol called with a class whose parent is not NPbase");
4517 if ((this->
getModel()).isModelLinearized()) {
4528 throw std::runtime_error(
"mueeWBFcc called with a class whose parent is not NPbase");
4534 if ((this->
getModel()).isModelLinearized()) {
4545 throw std::runtime_error(
"mueeWBFgg called with a class whose parent is not NPbase");
4551 if ((this->
getModel()).isModelLinearized()) {
4562 throw std::runtime_error(
"mueeWBFWW called with a class whose parent is not NPbase");
4568 if ((this->
getModel()).isModelLinearized()) {
4579 throw std::runtime_error(
"mueeWBFtautau called with a class whose parent is not NPbase");
4585 if ((this->
getModel()).isModelLinearized()) {
4596 throw std::runtime_error(
"mueeWBFZZ called with a class whose parent is not NPbase");
4602 if ((this->
getModel()).isModelLinearized()) {
4613 throw std::runtime_error(
"mueeWBFZga called with a class whose parent is not NPbase");
4619 if ((this->
getModel()).isModelLinearized()) {
4630 throw std::runtime_error(
"mueeWBFgaga called with a class whose parent is not NPbase");
4636 if ((this->
getModel()).isModelLinearized()) {
4647 throw std::runtime_error(
"mueeWBFmumu called with a class whose parent is not NPbase");
4653 if ((this->
getModel()).isModelLinearized()) {
4664 throw std::runtime_error(
"mueeHvvbb called with a class whose parent is not NPbase");
4670 if ((this->
getModel()).isModelLinearized()) {
4678:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4681 throw std::runtime_error(
"mueeHvvbbPol called with a class whose parent is not NPbase");
4687 if ((this->
getModel()).isModelLinearized()) {
4698 throw std::runtime_error(
"mueeHvvcc called with a class whose parent is not NPbase");
4704 if ((this->
getModel()).isModelLinearized()) {
4712:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4715 throw std::runtime_error(
"mueeHvvccPol called with a class whose parent is not NPbase");
4721 if ((this->
getModel()).isModelLinearized()) {
4733 throw std::runtime_error(
"mueeHvvss called with a class whose parent is not NPbase");
4739 if ((this->
getModel()).isModelLinearized()) {
4747:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4750 throw std::runtime_error(
"mueeHvvssPol called with a class whose parent is not NPbase");
4756 if ((this->
getModel()).isModelLinearized()) {
4768 throw std::runtime_error(
"mueeHvvgg called with a class whose parent is not NPbase");
4774 if ((this->
getModel()).isModelLinearized()) {
4782:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4785 throw std::runtime_error(
"mueeHvvggPol called with a class whose parent is not NPbase");
4791 if ((this->
getModel()).isModelLinearized()) {
4802 throw std::runtime_error(
"mueeHvvWW called with a class whose parent is not NPbase");
4808 if ((this->
getModel()).isModelLinearized()) {
4816:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4819 throw std::runtime_error(
"mueeHvvWWPol called with a class whose parent is not NPbase");
4825 if ((this->
getModel()).isModelLinearized()) {
4836 throw std::runtime_error(
"mueeHvvtautau called with a class whose parent is not NPbase");
4842 if ((this->
getModel()).isModelLinearized()) {
4850:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4853 throw std::runtime_error(
"mueeHvvtautauPol called with a class whose parent is not NPbase");
4859 if ((this->
getModel()).isModelLinearized()) {
4870 throw std::runtime_error(
"mueeHvvZZ called with a class whose parent is not NPbase");
4876 if ((this->
getModel()).isModelLinearized()) {
4884:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4887 throw std::runtime_error(
"mueeHvvZZPol called with a class whose parent is not NPbase");
4893 if ((this->
getModel()).isModelLinearized()) {
4904 throw std::runtime_error(
"mueeHvvZga called with a class whose parent is not NPbase");
4910 if ((this->
getModel()).isModelLinearized()) {
4918:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4921 throw std::runtime_error(
"mueeHvvZgaPol called with a class whose parent is not NPbase");
4927 if ((this->
getModel()).isModelLinearized()) {
4938 throw std::runtime_error(
"mueeHvvgaga called with a class whose parent is not NPbase");
4944 if ((this->
getModel()).isModelLinearized()) {
4952:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4955 throw std::runtime_error(
"mueeHvvgagaPol called with a class whose parent is not NPbase");
4961 if ((this->
getModel()).isModelLinearized()) {
4972 throw std::runtime_error(
"mueeHvvmumu called with a class whose parent is not NPbase");
4978 if ((this->
getModel()).isModelLinearized()) {
4986:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
4989 throw std::runtime_error(
"mueeHvvmumuPol called with a class whose parent is not NPbase");
4995 if ((this->
getModel()).isModelLinearized()) {
5006 throw std::runtime_error(
"mueeZBFbb called with a class whose parent is not NPbase");
5011 if ((this->
getModel()).isModelLinearized()) {
5019:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
5022 throw std::runtime_error(
"mueeZBFbbPol called with a class whose parent is not NPbase");
5027 if ((this->
getModel()).isModelLinearized()) {
5038 throw std::runtime_error(
"mueettHbb called with a class whose parent is not NPbase");
5043 if ((this->
getModel()).isModelLinearized()) {
5051:
ThObservable(SM_i), sqrt_s(sqrt_s_i), Pol_em(Pol_em_i), Pol_ep(Pol_ep_i)
5054 throw std::runtime_error(
"mueettHbbPol called with a class whose parent is not NPbase");
5059 if ((this->
getModel()).isModelLinearized()) {
5074 throw std::runtime_error(
"mummZH called with a class whose parent is not NPbase");
5087 throw std::runtime_error(
"mummHvv called with a class whose parent is not NPbase");
5100 throw std::runtime_error(
"mummHmm called with a class whose parent is not NPbase");
5113 throw std::runtime_error(
"mummttH called with a class whose parent is not NPbase");
5130 throw std::runtime_error(
"mummHbb called with a class whose parent is not NPbase");
5135 if ((this->
getModel()).isModelLinearized()) {
5146 throw std::runtime_error(
"mummHcc called with a class whose parent is not NPbase");
5151 if ((this->
getModel()).isModelLinearized()) {
5162 throw std::runtime_error(
"mummHgg called with a class whose parent is not NPbase");
5167 if ((this->
getModel()).isModelLinearized()) {
5178 throw std::runtime_error(
"mummHcc called with a class whose parent is not NPbase");
5183 if ((this->
getModel()).isModelLinearized()) {
5194 throw std::runtime_error(
"mummHtautau called with a class whose parent is not NPbase");
5199 if ((this->
getModel()).isModelLinearized()) {
5210 throw std::runtime_error(
"mummHZZ called with a class whose parent is not NPbase");
5215 if ((this->
getModel()).isModelLinearized()) {
5226 throw std::runtime_error(
"mummHZga called with a class whose parent is not NPbase");
5231 if ((this->
getModel()).isModelLinearized()) {
5242 throw std::runtime_error(
"mummHgaga called with a class whose parent is not NPbase");
5247 if ((this->
getModel()).isModelLinearized()) {
5258 throw std::runtime_error(
"mummHmumu called with a class whose parent is not NPbase");
5263 if ((this->
getModel()).isModelLinearized()) {
5276 throw std::runtime_error(
"mummZHbb called with a class whose parent is not NPbase");
5281 if ((this->
getModel()).isModelLinearized()) {
5292 throw std::runtime_error(
"mummZHcc called with a class whose parent is not NPbase");
5297 if ((this->
getModel()).isModelLinearized()) {
5308 throw std::runtime_error(
"mummZHgg called with a class whose parent is not NPbase");
5313 if ((this->
getModel()).isModelLinearized()) {
5324 throw std::runtime_error(
"mummZHcc called with a class whose parent is not NPbase");
5329 if ((this->
getModel()).isModelLinearized()) {
5340 throw std::runtime_error(
"mummZHtautau called with a class whose parent is not NPbase");
5345 if ((this->
getModel()).isModelLinearized()) {
5356 throw std::runtime_error(
"mummZHZZ called with a class whose parent is not NPbase");
5361 if ((this->
getModel()).isModelLinearized()) {
5372 throw std::runtime_error(
"mummZHZga called with a class whose parent is not NPbase");
5377 if ((this->
getModel()).isModelLinearized()) {
5388 throw std::runtime_error(
"mummZHgaga called with a class whose parent is not NPbase");
5393 if ((this->
getModel()).isModelLinearized()) {
5404 throw std::runtime_error(
"mummZHmumu called with a class whose parent is not NPbase");
5409 if ((this->
getModel()).isModelLinearized()) {
5422 throw std::runtime_error(
"mummHvvbb called with a class whose parent is not NPbase");
5427 if ((this->
getModel()).isModelLinearized()) {
5438 throw std::runtime_error(
"mummHvvcc called with a class whose parent is not NPbase");
5443 if ((this->
getModel()).isModelLinearized()) {
5454 throw std::runtime_error(
"mummHvvgg called with a class whose parent is not NPbase");
5459 if ((this->
getModel()).isModelLinearized()) {
5470 throw std::runtime_error(
"mummHvvcc called with a class whose parent is not NPbase");
5475 if ((this->
getModel()).isModelLinearized()) {
5486 throw std::runtime_error(
"mummHvvtautau called with a class whose parent is not NPbase");
5491 if ((this->
getModel()).isModelLinearized()) {
5502 throw std::runtime_error(
"mummHvvZZ called with a class whose parent is not NPbase");
5507 if ((this->
getModel()).isModelLinearized()) {
5518 throw std::runtime_error(
"mummHvvZga called with a class whose parent is not NPbase");
5523 if ((this->
getModel()).isModelLinearized()) {
5534 throw std::runtime_error(
"mummHvvgaga called with a class whose parent is not NPbase");
5539 if ((this->
getModel()).isModelLinearized()) {
5550 throw std::runtime_error(
"mummHvvmumu called with a class whose parent is not NPbase");
5555 if ((this->
getModel()).isModelLinearized()) {
5568 throw std::runtime_error(
"mummHmmbb called with a class whose parent is not NPbase");
5573 if ((this->
getModel()).isModelLinearized()) {
5584 throw std::runtime_error(
"mummHmmcc called with a class whose parent is not NPbase");
5589 if ((this->
getModel()).isModelLinearized()) {
5600 throw std::runtime_error(
"mummHmmgg called with a class whose parent is not NPbase");
5605 if ((this->
getModel()).isModelLinearized()) {
5616 throw std::runtime_error(
"mummHmmcc called with a class whose parent is not NPbase");
5621 if ((this->
getModel()).isModelLinearized()) {
5632 throw std::runtime_error(
"mummHmmtautau called with a class whose parent is not NPbase");
5637 if ((this->
getModel()).isModelLinearized()) {
5648 throw std::runtime_error(
"mummHmmZZ called with a class whose parent is not NPbase");
5653 if ((this->
getModel()).isModelLinearized()) {
5664 throw std::runtime_error(
"mummHmmZga called with a class whose parent is not NPbase");
5669 if ((this->
getModel()).isModelLinearized()) {
5680 throw std::runtime_error(
"mummHmmgaga called with a class whose parent is not NPbase");
5685 if ((this->
getModel()).isModelLinearized()) {
5696 throw std::runtime_error(
"mummHmmmumu called with a class whose parent is not NPbase");
5701 if ((this->
getModel()).isModelLinearized()) {
5713 throw std::runtime_error(
"mummttHbb called with a class whose parent is not NPbase");
5718 if ((this->
getModel()).isModelLinearized()) {
5729 throw std::runtime_error(
"mummttHcc called with a class whose parent is not NPbase");
5734 if ((this->
getModel()).isModelLinearized()) {
5745 throw std::runtime_error(
"mummttHgg called with a class whose parent is not NPbase");
5750 if ((this->
getModel()).isModelLinearized()) {
5761 throw std::runtime_error(
"mummttHcc called with a class whose parent is not NPbase");
5766 if ((this->
getModel()).isModelLinearized()) {
5777 throw std::runtime_error(
"mummttHtautau called with a class whose parent is not NPbase");
5782 if ((this->
getModel()).isModelLinearized()) {
5793 throw std::runtime_error(
"mummttHZZ called with a class whose parent is not NPbase");
5798 if ((this->
getModel()).isModelLinearized()) {
5809 throw std::runtime_error(
"mummttHZga called with a class whose parent is not NPbase");
5814 if ((this->
getModel()).isModelLinearized()) {
5825 throw std::runtime_error(
"mummttHgaga called with a class whose parent is not NPbase");
5830 if ((this->
getModel()).isModelLinearized()) {
5841 throw std::runtime_error(
"mummttHmumu called with a class whose parent is not NPbase");
5846 if ((this->
getModel()).isModelLinearized()) {
5860 throw std::runtime_error(
"mummHbbNWA called with a class whose parent is not NPbase");
5865 if ((this->
getModel()).isModelLinearized()) {
5876 throw std::runtime_error(
"mummHccNWA called with a class whose parent is not NPbase");
5881 if ((this->
getModel()).isModelLinearized()) {
5892 throw std::runtime_error(
"mummHggNWA called with a class whose parent is not NPbase");
5897 if ((this->
getModel()).isModelLinearized()) {
5908 throw std::runtime_error(
"mummHccNWA called with a class whose parent is not NPbase");
5913 if ((this->
getModel()).isModelLinearized()) {
5924 throw std::runtime_error(
"mummHtautauNWA called with a class whose parent is not NPbase");
5929 if ((this->
getModel()).isModelLinearized()) {
5940 throw std::runtime_error(
"mummHZZNWA called with a class whose parent is not NPbase");
5945 if ((this->
getModel()).isModelLinearized()) {
5956 throw std::runtime_error(
"mummHZgaNWA called with a class whose parent is not NPbase");
5961 if ((this->
getModel()).isModelLinearized()) {
5972 throw std::runtime_error(
"mummHgagaNWA called with a class whose parent is not NPbase");
5977 if ((this->
getModel()).isModelLinearized()) {
5988 throw std::runtime_error(
"mummHmumuNWA called with a class whose parent is not NPbase");
5993 if ((this->
getModel()).isModelLinearized()) {
6007 throw std::runtime_error(
"muepWBFbb called with a class whose parent is not NPbase");
6013 if ((this->
getModel()).isModelLinearized()) {
6024 throw std::runtime_error(
"muepWBFcc called with a class whose parent is not NPbase");
6030 if ((this->
getModel()).isModelLinearized()) {
6041 throw std::runtime_error(
"muepWBFgg called with a class whose parent is not NPbase");
6047 if ((this->
getModel()).isModelLinearized()) {
6058 throw std::runtime_error(
"muepWBFWW2l2v called with a class whose parent is not NPbase");
6064 if ((this->
getModel()).isModelLinearized()) {
6075 throw std::runtime_error(
"muepWBFZZ4l called with a class whose parent is not NPbase");
6081 if ((this->
getModel()).isModelLinearized()) {
6092 throw std::runtime_error(
"muepWBFgaga called with a class whose parent is not NPbase");
6098 if ((this->
getModel()).isModelLinearized()) {
6109 throw std::runtime_error(
"muepWBFtautau called with a class whose parent is not NPbase");
6115 if ((this->
getModel()).isModelLinearized()) {
6126 throw std::runtime_error(
"muepZBFbb called with a class whose parent is not NPbase");
6132 if ((this->
getModel()).isModelLinearized()) {
6143 throw std::runtime_error(
"muepZBFcc called with a class whose parent is not NPbase");
6149 if ((this->
getModel()).isModelLinearized()) {
6160 throw std::runtime_error(
"muepZBFgg called with a class whose parent is not NPbase");
6166 if ((this->
getModel()).isModelLinearized()) {
6177 throw std::runtime_error(
"muepZBFWW2l2v called with a class whose parent is not NPbase");
6183 if ((this->
getModel()).isModelLinearized()) {
6194 throw std::runtime_error(
"muepZBFZZ4l called with a class whose parent is not NPbase");
6200 if ((this->
getModel()).isModelLinearized()) {
6211 throw std::runtime_error(
"muepZBFgaga called with a class whose parent is not NPbase");
6217 if ((this->
getModel()).isModelLinearized()) {
6228 throw std::runtime_error(
"muepZBFtautau called with a class whose parent is not NPbase");
6234 if ((this->
getModel()).isModelLinearized()) {
6254 throw std::runtime_error(
"STXS_0_qqH called with a class whose parent is not NPbase");
6272 throw std::runtime_error(
"STXSggH_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6278 if ((this->
getModel()).isModelLinearized()) {
6290 throw std::runtime_error(
"STXSggH_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6296 if ((this->
getModel()).isModelLinearized()) {
6308 throw std::runtime_error(
"STXSggH0j4l called with a class whose parent is not NPbase");
6314 if ((this->
getModel()).isModelLinearized()) {
6325 throw std::runtime_error(
"STXSggH1j_pTH_0_60_4l called with a class whose parent is not NPbase");
6331 if ((this->
getModel()).isModelLinearized()) {
6342 throw std::runtime_error(
"STXSggH1j_pTH_60_120_4l called with a class whose parent is not NPbase");
6348 if ((this->
getModel()).isModelLinearized()) {
6359 throw std::runtime_error(
"STXSggH1j_pTH_120_200_4l called with a class whose parent is not NPbase");
6365 if ((this->
getModel()).isModelLinearized()) {
6376 throw std::runtime_error(
"STXSggH1j_pTH_200_4l called with a class whose parent is not NPbase");
6382 if ((this->
getModel()).isModelLinearized()) {
6393 throw std::runtime_error(
"STXSggH2j_pTH_0_200_4l called with a class whose parent is not NPbase");
6399 if ((this->
getModel()).isModelLinearized()) {
6411 throw std::runtime_error(
"STXSggH2j_pTH_0_60_4l called with a class whose parent is not NPbase");
6417 if ((this->
getModel()).isModelLinearized()) {
6429 throw std::runtime_error(
"STXSggH2j_pTH_60_120_4l called with a class whose parent is not NPbase");
6435 if ((this->
getModel()).isModelLinearized()) {
6447 throw std::runtime_error(
"STXSggH2j_pTH_120_200_4l called with a class whose parent is not NPbase");
6453 if ((this->
getModel()).isModelLinearized()) {
6465 throw std::runtime_error(
"STXSggH2j_pTH_200_4l called with a class whose parent is not NPbase");
6471 if ((this->
getModel()).isModelLinearized()) {
6483 throw std::runtime_error(
"STXSqqHqq_VBFtopo_Rest_4l called with a class whose parent is not NPbase");
6489 if ((this->
getModel()).isModelLinearized()) {
6501 throw std::runtime_error(
"STXSqqHqq_VBFtopo_j3v_4l called with a class whose parent is not NPbase");
6507 if ((this->
getModel()).isModelLinearized()) {
6520 throw std::runtime_error(
"STXSqqHqq_VBFtopo_j3_4l called with a class whose parent is not NPbase");
6526 if ((this->
getModel()).isModelLinearized()) {
6539 throw std::runtime_error(
"STXSqqHqq_nonVHtopo_4l called with a class whose parent is not NPbase");
6545 if ((this->
getModel()).isModelLinearized()) {
6558 throw std::runtime_error(
"STXSqqHqq_VHtopo_4l called with a class whose parent is not NPbase");
6564 if ((this->
getModel()).isModelLinearized()) {
6576 throw std::runtime_error(
"STXSqqHqq_Rest_4l called with a class whose parent is not NPbase");
6582 if ((this->
getModel()).isModelLinearized()) {
6594 throw std::runtime_error(
"STXSqqHqq_pTj_200_4l called with a class whose parent is not NPbase");
6600 if ((this->
getModel()).isModelLinearized()) {
6611 throw std::runtime_error(
"STXSqqHlv_pTV_0_250_4l called with a class whose parent is not NPbase");
6617 if ((this->
getModel()).isModelLinearized()) {
6629 throw std::runtime_error(
"STXSqqHlv_pTV_0_150_4l called with a class whose parent is not NPbase");
6635 if ((this->
getModel()).isModelLinearized()) {
6648 throw std::runtime_error(
"STXSqqHlv_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6654 if ((this->
getModel()).isModelLinearized()) {
6667 throw std::runtime_error(
"STXSqqHlv_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6673 if ((this->
getModel()).isModelLinearized()) {
6685 throw std::runtime_error(
"STXSqqHlv_pTV_250_4l called with a class whose parent is not NPbase");
6691 if ((this->
getModel()).isModelLinearized()) {
6702 throw std::runtime_error(
"STXSqqHll_pTV_0_150_4l called with a class whose parent is not NPbase");
6708 if ((this->
getModel()).isModelLinearized()) {
6719 throw std::runtime_error(
"STXSqqHll_pTV_150_250_4l called with a class whose parent is not NPbase");
6725 if ((this->
getModel()).isModelLinearized()) {
6737 throw std::runtime_error(
"STXSqqHll_pTV_150_250_0j_4l called with a class whose parent is not NPbase");
6743 if ((this->
getModel()).isModelLinearized()) {
6755 throw std::runtime_error(
"STXSqqHll_pTV_150_250_1j_4l called with a class whose parent is not NPbase");
6761 if ((this->
getModel()).isModelLinearized()) {
6773 throw std::runtime_error(
"STXSqqHll_pTV_250_4l called with a class whose parent is not NPbase");
6779 if ((this->
getModel()).isModelLinearized()) {
6790 throw std::runtime_error(
"STXSttHtH4l called with a class whose parent is not NPbase");
6796 if ((this->
getModel()).isModelLinearized()) {
6808 throw std::runtime_error(
"STXSqqHlv_pTV_0_250_bb called with a class whose parent is not NPbase");
6814 if ((this->
getModel()).isModelLinearized()) {
6826 throw std::runtime_error(
"STXSqqHlv_pTV_0_150_bb called with a class whose parent is not NPbase");
6832 if ((this->
getModel()).isModelLinearized()) {
6845 throw std::runtime_error(
"STXSqqHlv_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6851 if ((this->
getModel()).isModelLinearized()) {
6864 throw std::runtime_error(
"STXSqqHlv_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6870 if ((this->
getModel()).isModelLinearized()) {
6882 throw std::runtime_error(
"STXSqqHlv_pTV_250_bb called with a class whose parent is not NPbase");
6888 if ((this->
getModel()).isModelLinearized()) {
6899 throw std::runtime_error(
"STXSqqHll_pTV_0_150_bb called with a class whose parent is not NPbase");
6905 if ((this->
getModel()).isModelLinearized()) {
6916 throw std::runtime_error(
"STXSqqHll_pTV_150_250_bb called with a class whose parent is not NPbase");
6922 if ((this->
getModel()).isModelLinearized()) {
6934 throw std::runtime_error(
"STXSqqHll_pTV_150_250_0j_bb called with a class whose parent is not NPbase");
6940 if ((this->
getModel()).isModelLinearized()) {
6952 throw std::runtime_error(
"STXSqqHll_pTV_150_250_1j_bb called with a class whose parent is not NPbase");
6958 if ((this->
getModel()).isModelLinearized()) {
6970 throw std::runtime_error(
"STXSqqHll_pTV_250_bb called with a class whose parent is not NPbase");
6976 if ((this->
getModel()).isModelLinearized()) {
6988 throw std::runtime_error(
"STXSWHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
6994 if ((this->
getModel()).isModelLinearized()) {
7006 throw std::runtime_error(
"STXSWHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
7012 if ((this->
getModel()).isModelLinearized()) {
7024 throw std::runtime_error(
"STXSWHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
7030 if ((this->
getModel()).isModelLinearized()) {
7042 throw std::runtime_error(
"STXSWHqqHqq_Rest_2b called with a class whose parent is not NPbase");
7048 if ((this->
getModel()).isModelLinearized()) {
7060 throw std::runtime_error(
"STXSWHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7066 if ((this->
getModel()).isModelLinearized()) {
7078 throw std::runtime_error(
"STXSZHqqHqq_VBFtopo_j3v_2b called with a class whose parent is not NPbase");
7084 if ((this->
getModel()).isModelLinearized()) {
7096 throw std::runtime_error(
"STXSZHqqHqq_VBFtopo_j3_2b called with a class whose parent is not NPbase");
7102 if ((this->
getModel()).isModelLinearized()) {
7114 throw std::runtime_error(
"STXSZHqqHqq_VH2j_2b called with a class whose parent is not NPbase");
7120 if ((this->
getModel()).isModelLinearized()) {
7132 throw std::runtime_error(
"STXSZHqqHqq_Rest_2b called with a class whose parent is not NPbase");
7138 if ((this->
getModel()).isModelLinearized()) {
7150 throw std::runtime_error(
"STXSZHqqHqq_pTj1_200_2b called with a class whose parent is not NPbase");
7156 if ((this->
getModel()).isModelLinearized()) {
7170:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7173 throw std::runtime_error(
"STXS12_ggH_pTH200_300_Nj01 called with a class whose parent is not NPbase");
7179 double BrHXXRatio = 1.0;
7189 throw std::runtime_error(
"STXS12_ggH_pTH200_300_Nj01 called with invalid argument for final state in fstate_i");
7192 if ((this->
getModel()).isModelLinearized()) {
7202:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7205 throw std::runtime_error(
"STXS12_ggH_pTH300_450_Nj01 called with a class whose parent is not NPbase");
7211 double BrHXXRatio = 1.0;
7221 throw std::runtime_error(
"STXS12_ggH_pTH300_450_Nj01 called with invalid argument for final state in fstate_i");
7224 if ((this->
getModel()).isModelLinearized()) {
7234:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7237 throw std::runtime_error(
"STXS12_ggH_pTH450_650_Nj01 called with a class whose parent is not NPbase");
7243 double BrHXXRatio = 1.0;
7253 throw std::runtime_error(
"STXS12_ggH_pTH450_650_Nj01 called with invalid argument for final state in fstate_i");
7256 if ((this->
getModel()).isModelLinearized()) {
7266:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7269 throw std::runtime_error(
"STXS12_ggH_pTH650_Inf_Nj01 called with a class whose parent is not NPbase");
7275 double BrHXXRatio = 1.0;
7285 throw std::runtime_error(
"STXS12_ggH_pTH650_Inf_Nj01 called with invalid argument for final state in fstate_i");
7288 if ((this->
getModel()).isModelLinearized()) {
7299:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7302 throw std::runtime_error(
"STXS12_ggH_pTH10_Inf_Nj0 called with a class whose parent is not NPbase");
7309 double weight = 1.0;
7312 double muProd1 = muProd -1.0;
7313 double muProd2 = 0.0;
7315 double BrHXXRatio = 1.0;
7316 double dBrHXXRatio1 = 0.0;
7317 double dBrHXXRatio2 = 0.0;
7321 dBrHXXRatio1 = BrHXXRatio - 1.0;
7325 dBrHXXRatio1 = BrHXXRatio - 1.0;
7329 dBrHXXRatio1 = BrHXXRatio - 1.0;
7333 dBrHXXRatio1 = BrHXXRatio - 1.0;
7336 throw std::runtime_error(
"STXS12_ggH_pTH10_Inf_Nj0 called with invalid argument for final state in fstate_i");
7340 if ((this->
getModel()).isModelLinearized()){
7341 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7342 }
else if((this->
getModel()).isModelNPquadratic()){
7343 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7345 return weight*(muProd)*(BrHXXRatio);
7357:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7360 throw std::runtime_error(
"STXS12_ggH_pTH0_10_Nj0 called with a class whose parent is not NPbase");
7367 double weight = 1.0;
7370 double muProd1 = muProd -1.0;
7371 double muProd2 = 0.0;
7374 double BrHXXRatio = 1.0;
7375 double dBrHXXRatio1 = 0.0;
7376 double dBrHXXRatio2 = 0.0;
7382 dBrHXXRatio1 = BrHXXRatio - 1.0;
7386 dBrHXXRatio1 = BrHXXRatio - 1.0;
7390 dBrHXXRatio1 = BrHXXRatio - 1.0;
7394 dBrHXXRatio1 = BrHXXRatio - 1.0;
7398 dBrHXXRatio1 = BrHXXRatio - 1.0;
7402 dBrHXXRatio1 = BrHXXRatio - 1.0;
7406 dBrHXXRatio1 = BrHXXRatio - 1.0;
7409 throw std::runtime_error(
"STXS12_ggH_pTH0_10_Nj0 called with invalid argument for final state in fstate_i");
7413 if ((this->
getModel()).isModelLinearized()){
7414 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7415 }
else if((this->
getModel()).isModelNPquadratic()){
7416 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7418 return weight*(muProd)*(BrHXXRatio);
7429:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7432 throw std::runtime_error(
"STXS12_ggH_pTH10_200_Nj0 called with a class whose parent is not NPbase");
7439 double weight = 1.0;
7442 double muProd1 = muProd -1.0;
7443 double muProd2 = 0.0;
7446 double BrHXXRatio = 1.0;
7447 double dBrHXXRatio1 = 0.0;
7448 double dBrHXXRatio2 = 0.0;
7454 dBrHXXRatio1 = BrHXXRatio - 1.0;
7458 dBrHXXRatio1 = BrHXXRatio - 1.0;
7462 dBrHXXRatio1 = BrHXXRatio - 1.0;
7466 dBrHXXRatio1 = BrHXXRatio - 1.0;
7470 dBrHXXRatio1 = BrHXXRatio - 1.0;
7474 dBrHXXRatio1 = BrHXXRatio - 1.0;
7478 dBrHXXRatio1 = BrHXXRatio - 1.0;
7481 throw std::runtime_error(
"STXS12_ggH_pTH10_200_Nj0 called with invalid argument for final state in fstate_i");
7485 if ((this->
getModel()).isModelLinearized()){
7486 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7487 }
else if((this->
getModel()).isModelNPquadratic()){
7488 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7490 return weight*(muProd)*(BrHXXRatio);
7502:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7505 throw std::runtime_error(
"STXS12_ggH_pTH0_200_Nj0 called with a class whose parent is not NPbase");
7512 double weight = 1.0;
7517 double muProd1 = muProd -1.0;
7518 double muProd2 = 0.0;
7521 double BrHXXRatio = 1.0;
7522 double dBrHXXRatio1 = 0.0;
7523 double dBrHXXRatio2 = 0.0;
7526 weight = (6.6369 + 20.642);
7529 dBrHXXRatio1 = BrHXXRatio - 1.0;
7533 dBrHXXRatio1 = BrHXXRatio - 1.0;
7537 dBrHXXRatio1 = BrHXXRatio - 1.0;
7541 dBrHXXRatio1 = BrHXXRatio - 1.0;
7545 dBrHXXRatio1 = BrHXXRatio - 1.0;
7549 dBrHXXRatio1 = BrHXXRatio - 1.0;
7553 dBrHXXRatio1 = BrHXXRatio - 1.0;
7556 throw std::runtime_error(
"STXS12_ggH_pTH0_200_Nj0 called with invalid argument for final state in fstate_i");
7560 if ((this->
getModel()).isModelLinearized()){
7561 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7562 }
else if((this->
getModel()).isModelNPquadratic()){
7563 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7565 return weight*(muProd)*(BrHXXRatio);
7577:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7580 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7587 double weight = 1.0;
7591 double muProd1 = muProd -1.0;
7592 double muProd2 = 0.0;
7595 double BrHXXRatio = 1.0;
7596 double dBrHXXRatio1 = 0.0;
7597 double dBrHXXRatio2 = 0.0;
7603 dBrHXXRatio1 = BrHXXRatio - 1.0;
7607 dBrHXXRatio1 = BrHXXRatio - 1.0;
7611 dBrHXXRatio1 = BrHXXRatio - 1.0;
7615 dBrHXXRatio1 = BrHXXRatio - 1.0;
7619 dBrHXXRatio1 = BrHXXRatio - 1.0;
7623 dBrHXXRatio1 = BrHXXRatio - 1.0;
7627 dBrHXXRatio1 = BrHXXRatio - 1.0;
7630 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_120_Nj1 called with invalid argument for final state in fstate_i");
7634 if ((this->
getModel()).isModelLinearized()){
7635 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7636 }
else if((this->
getModel()).isModelNPquadratic()){
7637 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7639 return weight*(muProd)*(BrHXXRatio);
7654:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7657 throw std::runtime_error(
"STXS12_ggH_pTH0_60_Nj1 called with a class whose parent is not NPbase");
7664 double weight = 1.0;
7666 double muProd1 = muProd -1.0;
7667 double muProd2 = 0.0;
7670 double BrHXXRatio = 1.0;
7671 double dBrHXXRatio1 = 0.0;
7672 double dBrHXXRatio2 = 0.0;
7678 dBrHXXRatio1 = BrHXXRatio - 1.0;
7682 dBrHXXRatio1 = BrHXXRatio - 1.0;
7686 dBrHXXRatio1 = BrHXXRatio - 1.0;
7690 dBrHXXRatio1 = BrHXXRatio - 1.0;
7694 dBrHXXRatio1 = BrHXXRatio - 1.0;
7698 dBrHXXRatio1 = BrHXXRatio - 1.0;
7702 dBrHXXRatio1 = BrHXXRatio - 1.0;
7705 throw std::runtime_error(
"STXS12_ggH_pTH0_60_Nj1 called with invalid argument for final state in fstate_i");
7709 if ((this->
getModel()).isModelLinearized()){
7710 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7711 }
else if((this->
getModel()).isModelNPquadratic()){
7712 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7714 return weight*(muProd)*(BrHXXRatio);
7723:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7726 throw std::runtime_error(
"STXS12_ggH_pTH60_120_Nj1 called with a class whose parent is not NPbase");
7733 double weight = 1.0;
7735 double muProd1 = muProd -1.0;
7736 double muProd2 = 0.0;
7739 double BrHXXRatio = 1.0;
7740 double dBrHXXRatio1 = 0.0;
7741 double dBrHXXRatio2 = 0.0;
7747 dBrHXXRatio1 = BrHXXRatio - 1.0;
7751 dBrHXXRatio1 = BrHXXRatio - 1.0;
7755 dBrHXXRatio1 = BrHXXRatio - 1.0;
7759 dBrHXXRatio1 = BrHXXRatio - 1.0;
7763 dBrHXXRatio1 = BrHXXRatio - 1.0;
7767 dBrHXXRatio1 = BrHXXRatio - 1.0;
7771 dBrHXXRatio1 = BrHXXRatio - 1.0;
7774 throw std::runtime_error(
"STXS12_ggH_pTH60_120_Nj1 called with invalid argument for final state in fstate_i");
7778 if ((this->
getModel()).isModelLinearized()){
7779 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7780 }
else if((this->
getModel()).isModelNPquadratic()){
7781 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7783 return weight*(muProd)*(BrHXXRatio);
7792:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7795 throw std::runtime_error(
"STXS12_ggH_pTH120_200_Nj1 called with a class whose parent is not NPbase");
7802 double weight = 1.0;
7804 double muProd1 = muProd -1.0;
7805 double muProd2 = 0.0;
7808 double BrHXXRatio = 1.0;
7809 double dBrHXXRatio1 = 0.0;
7810 double dBrHXXRatio2 = 0.0;
7816 dBrHXXRatio1 = BrHXXRatio - 1.0;
7820 dBrHXXRatio1 = BrHXXRatio - 1.0;
7824 dBrHXXRatio1 = BrHXXRatio - 1.0;
7828 dBrHXXRatio1 = BrHXXRatio - 1.0;
7832 dBrHXXRatio1 = BrHXXRatio - 1.0;
7836 dBrHXXRatio1 = BrHXXRatio - 1.0;
7840 dBrHXXRatio1 = BrHXXRatio - 1.0;
7843 throw std::runtime_error(
"STXS12_ggH_pTH120_200_Nj1 called with invalid argument for final state in fstate_i");
7847 if ((this->
getModel()).isModelLinearized()){
7848 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7849 }
else if((this->
getModel()).isModelNPquadratic()){
7850 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7852 return weight*(muProd)*(BrHXXRatio);
7863:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7866 throw std::runtime_error(
"STXS12_ggH_pTH60_200_Nj1 called with a class whose parent is not NPbase");
7873 double weight = 1.0;
7876 )/(4.50294+0.74712);
7877 double muProd1 = muProd -1.0;
7878 double muProd2 = 0.0;
7881 double BrHXXRatio = 1.0;
7882 double dBrHXXRatio1 = 0.0;
7883 double dBrHXXRatio2 = 0.0;
7886 weight = (4.50294+0.74712);
7889 dBrHXXRatio1 = BrHXXRatio - 1.0;
7893 dBrHXXRatio1 = BrHXXRatio - 1.0;
7897 dBrHXXRatio1 = BrHXXRatio - 1.0;
7901 dBrHXXRatio1 = BrHXXRatio - 1.0;
7905 dBrHXXRatio1 = BrHXXRatio - 1.0;
7909 dBrHXXRatio1 = BrHXXRatio - 1.0;
7913 dBrHXXRatio1 = BrHXXRatio - 1.0;
7916 throw std::runtime_error(
"STXS12_ggH_pTH60_200_Nj1 called with invalid argument for final state in fstate_i");
7920 if ((this->
getModel()).isModelLinearized()){
7921 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7922 }
else if((this->
getModel()).isModelNPquadratic()){
7923 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
7925 return weight*(muProd)*(BrHXXRatio);
7934:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
7937 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with a class whose parent is not NPbase");
7946 double weight = 1.0;
7949 double muProd1 = muProd -1.0;
7950 double muProd2 = 0.0;
7953 double BrHXXRatio = 1.0;
7954 double dBrHXXRatio1 = 0.0;
7955 double dBrHXXRatio2 = 0.0;
7964 dBrHXXRatio1 = BrHXXRatio - 1.0;
7968 dBrHXXRatio1 = BrHXXRatio - 1.0;
7972 dBrHXXRatio1 = BrHXXRatio - 1.0;
7976 dBrHXXRatio1 = BrHXXRatio - 1.0;
7980 dBrHXXRatio1 = BrHXXRatio - 1.0;
7984 dBrHXXRatio1 = BrHXXRatio - 1.0;
7988 dBrHXXRatio1 = BrHXXRatio - 1.0;
7991 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_60_Nj2 called with invalid argument for final state in fstate_i");
7997 if ((this->
getModel()).isModelLinearized()){
7998 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
7999 }
else if((this->
getModel()).isModelNPquadratic()){
8000 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8002 return weight*(muProd)*(BrHXXRatio);
8009:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8012 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with a class whose parent is not NPbase");
8020 double weight = 1.0;
8024 double muProd1 = muProd -1.0;
8025 double muProd2 = 0.0;
8028 double BrHXXRatio = 1.0;
8029 double dBrHXXRatio1 = 0.0;
8030 double dBrHXXRatio2 = 0.0;
8039 dBrHXXRatio1 = BrHXXRatio - 1.0;
8043 dBrHXXRatio1 = BrHXXRatio - 1.0;
8047 dBrHXXRatio1 = BrHXXRatio - 1.0;
8051 dBrHXXRatio1 = BrHXXRatio - 1.0;
8055 dBrHXXRatio1 = BrHXXRatio - 1.0;
8059 dBrHXXRatio1 = BrHXXRatio - 1.0;
8063 dBrHXXRatio1 = BrHXXRatio - 1.0;
8066 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH60_120_Nj2 called with invalid argument for final state in fstate_i");
8070 if ((this->
getModel()).isModelLinearized()){
8071 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8072 }
else if((this->
getModel()).isModelNPquadratic()){
8073 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8075 return weight*(muProd)*(BrHXXRatio);
8087:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8090 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with a class whose parent is not NPbase");
8097 double weight = 1.0;
8103 double muProd1 = muProd -1.0;
8104 double muProd2 = 0.0;
8107 double BrHXXRatio = 1.0;
8108 double dBrHXXRatio1 = 0.0;
8109 double dBrHXXRatio2 = 0.0;
8120 dBrHXXRatio1 = BrHXXRatio - 1.0;
8124 dBrHXXRatio1 = BrHXXRatio - 1.0;
8128 dBrHXXRatio1 = BrHXXRatio - 1.0;
8132 dBrHXXRatio1 = BrHXXRatio - 1.0;
8136 dBrHXXRatio1 = BrHXXRatio - 1.0;
8140 dBrHXXRatio1 = BrHXXRatio - 1.0;
8144 dBrHXXRatio1 = BrHXXRatio - 1.0;
8147 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH0_120_Nj2 called with invalid argument for final state in fstate_i");
8151 if ((this->
getModel()).isModelLinearized()){
8152 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8153 }
else if((this->
getModel()).isModelNPquadratic()){
8154 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8156 return weight*(muProd)*(BrHXXRatio);
8168:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8171 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with a class whose parent is not NPbase");
8178 double weight = 1.0;
8180 double muProd1 = muProd -1.0;
8181 double muProd2 = 0.0;
8184 double BrHXXRatio = 1.0;
8185 double dBrHXXRatio1 = 0.0;
8186 double dBrHXXRatio2 = 0.0;
8192 dBrHXXRatio1 = BrHXXRatio - 1.0;
8196 dBrHXXRatio1 = BrHXXRatio - 1.0;
8200 dBrHXXRatio1 = BrHXXRatio - 1.0;
8204 dBrHXXRatio1 = BrHXXRatio - 1.0;
8208 dBrHXXRatio1 = BrHXXRatio - 1.0;
8212 dBrHXXRatio1 = BrHXXRatio - 1.0;
8216 dBrHXXRatio1 = BrHXXRatio - 1.0;
8219 throw std::runtime_error(
"STXS12_ggH_mjj0_350_pTH120_200_Nj2 called with invalid argument for final state in fstate_i");
8223 if ((this->
getModel()).isModelLinearized()){
8224 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8225 }
else if((this->
getModel()).isModelNPquadratic()){
8226 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8228 return weight*(muProd)*(BrHXXRatio);
8238:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8241 throw std::runtime_error(
"STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8248 double weight = 1.0;
8256 double muProd1 = muProd -1.0;
8257 double muProd2 = 0.0;
8260 double BrHXXRatio = 1.0;
8261 double dBrHXXRatio1 = 0.0;
8262 double dBrHXXRatio2 = 0.0;
8268 dBrHXXRatio1 = BrHXXRatio - 1.0;
8272 dBrHXXRatio1 = BrHXXRatio - 1.0;
8276 dBrHXXRatio1 = BrHXXRatio - 1.0;
8280 dBrHXXRatio1 = BrHXXRatio - 1.0;
8284 dBrHXXRatio1 = BrHXXRatio - 1.0;
8288 dBrHXXRatio1 = BrHXXRatio - 1.0;
8292 dBrHXXRatio1 = BrHXXRatio - 1.0;
8295 throw std::runtime_error(
"STXS12_ggH_mjj350_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8299 if ((this->
getModel()).isModelLinearized()){
8300 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8301 }
else if((this->
getModel()).isModelNPquadratic()){
8302 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8304 return weight*(muProd)*(BrHXXRatio);
8313:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8316 throw std::runtime_error(
"STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8322 double BrHXXRatio = 1.0;
8332 throw std::runtime_error(
"STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8335 if ((this->
getModel()).isModelLinearized()) {
8345:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8349 throw std::runtime_error(
"STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8355 double BrHXXRatio = 1.0;
8365 throw std::runtime_error(
"STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8368 if ((this->
getModel()).isModelLinearized()) {
8378:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8381 throw std::runtime_error(
"STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with a class whose parent is not NPbase");
8387 double BrHXXRatio = 1.0;
8397 throw std::runtime_error(
"STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
8400 if ((this->
getModel()).isModelLinearized()) {
8410:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8413 throw std::runtime_error(
"STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
8419 double BrHXXRatio = 1.0;
8429 throw std::runtime_error(
"STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
8432 if ((this->
getModel()).isModelLinearized()) {
8447:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8450 throw std::runtime_error(
"STXS12_ggH_pTH0_200_Nj2 called with a class whose parent is not NPbase");
8460 double weight = 1.0;
8472 )/(1.24+2.00+0.94321+0.87751);
8473 double muProd1 = muProd -1.0;
8474 double muProd2 = 0.0;
8477 double BrHXXRatio = 1.0;
8478 double dBrHXXRatio1 = 0.0;
8479 double dBrHXXRatio2 = 0.0;
8482 weight = (1.24+2.00+0.94321+0.87751);
8485 dBrHXXRatio1 = BrHXXRatio - 1.0;
8489 dBrHXXRatio1 = BrHXXRatio - 1.0;
8493 dBrHXXRatio1 = BrHXXRatio - 1.0;
8497 dBrHXXRatio1 = BrHXXRatio - 1.0;
8501 dBrHXXRatio1 = BrHXXRatio - 1.0;
8505 dBrHXXRatio1 = BrHXXRatio - 1.0;
8509 dBrHXXRatio1 = BrHXXRatio - 1.0;
8512 throw std::runtime_error(
"STXS12_ggH_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
8516 if ((this->
getModel()).isModelLinearized()){
8517 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8518 }
else if((this->
getModel()).isModelNPquadratic()){
8519 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8521 return weight*(muProd)*(BrHXXRatio);
8537:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8540 throw std::runtime_error(
"STXS12_ggH_pTH200_Inf called with a class whose parent is not NPbase");
8547 double weight = 1.0;
8552 /(0.45825 + 0.10632 + 0.017974);
8553 double muProd1 = muProd -1.0;
8554 double muProd2 = 0.0;
8557 double BrHXXRatio = 1.0;
8558 double dBrHXXRatio1 = 0.0;
8559 double dBrHXXRatio2 = 0.0;
8562 weight = (0.45825 + 0.10632 + 0.017974);
8565 dBrHXXRatio1 = BrHXXRatio - 1.0;
8569 dBrHXXRatio1 = BrHXXRatio - 1.0;
8573 dBrHXXRatio1 = BrHXXRatio - 1.0;
8577 dBrHXXRatio1 = BrHXXRatio - 1.0;
8581 dBrHXXRatio1 = BrHXXRatio - 1.0;
8585 dBrHXXRatio1 = BrHXXRatio - 1.0;
8589 dBrHXXRatio1 = BrHXXRatio - 1.0;
8592 throw std::runtime_error(
"STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8596 if ((this->
getModel()).isModelLinearized()){
8597 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8598 }
else if((this->
getModel()).isModelNPquadratic()){
8599 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8601 return weight*(muProd)*(BrHXXRatio);
8614:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8617 throw std::runtime_error(
"STXS12_ggH_pTH300_Inf called with a class whose parent is not NPbase");
8624 double weight = 1.0;
8628 /(0.10632 + 0.017974);
8629 double muProd1 = muProd -1.0;
8630 double muProd2 = 0.0;
8633 double BrHXXRatio = 1.0;
8634 double dBrHXXRatio1 = 0.0;
8635 double dBrHXXRatio2 = 0.0;
8638 weight = (0.10632 + 0.017974);
8641 dBrHXXRatio1 = BrHXXRatio - 1.0;
8645 dBrHXXRatio1 = BrHXXRatio - 1.0;
8649 dBrHXXRatio1 = BrHXXRatio - 1.0;
8653 dBrHXXRatio1 = BrHXXRatio - 1.0;
8657 dBrHXXRatio1 = BrHXXRatio - 1.0;
8661 dBrHXXRatio1 = BrHXXRatio - 1.0;
8665 dBrHXXRatio1 = BrHXXRatio - 1.0;
8668 throw std::runtime_error(
"STXS12_ggH_pTH200_Inf called with invalid argument for final state in fstate_i");
8672 if ((this->
getModel()).isModelLinearized()){
8673 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8674 }
else if((this->
getModel()).isModelNPquadratic()){
8675 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8677 return weight*(muProd)*(BrHXXRatio);
8688:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8691 throw std::runtime_error(
"STXS12_ggH_pTH200_300 called with a class whose parent is not NPbase");
8698 double weight = 1.0;
8701 double muProd1 = muProd -1.0;
8702 double muProd2 = 0.0;
8705 double BrHXXRatio = 1.0;
8706 double dBrHXXRatio1 = 0.0;
8707 double dBrHXXRatio2 = 0.0;
8710 weight = (0.45825 );
8713 dBrHXXRatio1 = BrHXXRatio - 1.0;
8717 dBrHXXRatio1 = BrHXXRatio - 1.0;
8721 dBrHXXRatio1 = BrHXXRatio - 1.0;
8725 dBrHXXRatio1 = BrHXXRatio - 1.0;
8729 dBrHXXRatio1 = BrHXXRatio - 1.0;
8733 dBrHXXRatio1 = BrHXXRatio - 1.0;
8737 dBrHXXRatio1 = BrHXXRatio - 1.0;
8740 throw std::runtime_error(
"STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
8744 if ((this->
getModel()).isModelLinearized()){
8745 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8746 }
else if((this->
getModel()).isModelNPquadratic()){
8747 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8749 return weight*(muProd)*(BrHXXRatio);
8761:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8764 throw std::runtime_error(
"STXS12_ggH_pTH300_450 called with a class whose parent is not NPbase");
8771 double weight = 1.0;
8774 double muProd1 = muProd -1.0;
8775 double muProd2 = 0.0;
8778 double BrHXXRatio = 1.0;
8779 double dBrHXXRatio1 = 0.0;
8780 double dBrHXXRatio2 = 0.0;
8786 dBrHXXRatio1 = BrHXXRatio - 1.0;
8790 dBrHXXRatio1 = BrHXXRatio - 1.0;
8794 dBrHXXRatio1 = BrHXXRatio - 1.0;
8798 dBrHXXRatio1 = BrHXXRatio - 1.0;
8802 dBrHXXRatio1 = BrHXXRatio - 1.0;
8806 dBrHXXRatio1 = BrHXXRatio - 1.0;
8810 dBrHXXRatio1 = BrHXXRatio - 1.0;
8813 throw std::runtime_error(
"STXS12_ggH_pTH300_450 called with invalid argument for final state in fstate_i");
8817 if ((this->
getModel()).isModelLinearized()){
8818 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8819 }
else if((this->
getModel()).isModelNPquadratic()){
8820 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8822 return weight*(muProd)*(BrHXXRatio);
8835:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8838 throw std::runtime_error(
"STXS12_ggH_pTH450_650 called with a class whose parent is not NPbase");
8845 double weight = 1.0;
8848 double muProd1 = muProd -1.0;
8849 double muProd2 = 0.0;
8852 double BrHXXRatio = 1.0;
8853 double dBrHXXRatio1 = 0.0;
8854 double dBrHXXRatio2 = 0.0;
8860 dBrHXXRatio1 = BrHXXRatio - 1.0;
8864 dBrHXXRatio1 = BrHXXRatio - 1.0;
8868 dBrHXXRatio1 = BrHXXRatio - 1.0;
8872 dBrHXXRatio1 = BrHXXRatio - 1.0;
8876 dBrHXXRatio1 = BrHXXRatio - 1.0;
8880 dBrHXXRatio1 = BrHXXRatio - 1.0;
8884 dBrHXXRatio1 = BrHXXRatio - 1.0;
8887 throw std::runtime_error(
"STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8891 if ((this->
getModel()).isModelLinearized()){
8892 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8893 }
else if((this->
getModel()).isModelNPquadratic()){
8894 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8896 return weight*(muProd)*(BrHXXRatio);
8908:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8911 throw std::runtime_error(
"STXS12_ggH_pTH650_Inf called with a class whose parent is not NPbase");
8918 double weight = 1.0;
8921 double muProd1 = muProd -1.0;
8922 double muProd2 = 0.0;
8925 double BrHXXRatio = 1.0;
8926 double dBrHXXRatio1 = 0.0;
8927 double dBrHXXRatio2 = 0.0;
8933 dBrHXXRatio1 = BrHXXRatio - 1.0;
8937 dBrHXXRatio1 = BrHXXRatio - 1.0;
8941 dBrHXXRatio1 = BrHXXRatio - 1.0;
8945 dBrHXXRatio1 = BrHXXRatio - 1.0;
8949 dBrHXXRatio1 = BrHXXRatio - 1.0;
8953 dBrHXXRatio1 = BrHXXRatio - 1.0;
8957 dBrHXXRatio1 = BrHXXRatio - 1.0;
8960 throw std::runtime_error(
"STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
8964 if ((this->
getModel()).isModelLinearized()){
8965 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
8966 }
else if((this->
getModel()).isModelNPquadratic()){
8967 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
8969 return weight*(muProd)*(BrHXXRatio);
8981:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
8984 throw std::runtime_error(
"STXS12_ggH_pTH450_Inf called with a class whose parent is not NPbase");
8991 double weight = 1.0;
8994 double muProd1 = muProd -1.0;
8995 double muProd2 = 0.0;
8998 double BrHXXRatio = 1.0;
8999 double dBrHXXRatio1 = 0.0;
9000 double dBrHXXRatio2 = 0.0;
9006 dBrHXXRatio1 = BrHXXRatio - 1.0;
9010 dBrHXXRatio1 = BrHXXRatio - 1.0;
9014 dBrHXXRatio1 = BrHXXRatio - 1.0;
9018 dBrHXXRatio1 = BrHXXRatio - 1.0;
9022 dBrHXXRatio1 = BrHXXRatio - 1.0;
9026 dBrHXXRatio1 = BrHXXRatio - 1.0;
9030 dBrHXXRatio1 = BrHXXRatio - 1.0;
9033 throw std::runtime_error(
"STXS12_ggH_pTH450_Inf called with invalid argument for final state in fstate_i");
9037 if ((this->
getModel()).isModelLinearized()){
9038 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9039 }
else if((this->
getModel()).isModelNPquadratic()){
9040 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9042 return weight*(muProd)*(BrHXXRatio);
9051:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9054 throw std::runtime_error(
"STXS12_ggHll_pTV0_75 called with a class whose parent is not NPbase");
9060 double BrHXXRatio = 1.0;
9070 throw std::runtime_error(
"STXS12_ggHll_pTV0_75 called with invalid argument for final state in fstate_i");
9073 if ((this->
getModel()).isModelLinearized()) {
9083:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9086 throw std::runtime_error(
"STXS12_ggHll_pTV75_150 called with a class whose parent is not NPbase");
9092 double BrHXXRatio = 1.0;
9102 throw std::runtime_error(
"STXS12_ggHll_pTV75_150 called with invalid argument for final state in fstate_i");
9105 if ((this->
getModel()).isModelLinearized()) {
9115:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9118 throw std::runtime_error(
"STXS12_ggHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
9124 double BrHXXRatio = 1.0;
9134 throw std::runtime_error(
"STXS12_ggHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
9137 if ((this->
getModel()).isModelLinearized()) {
9147:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9150 throw std::runtime_error(
"STXS12_ggHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
9156 double BrHXXRatio = 1.0;
9166 throw std::runtime_error(
"STXS12_ggHll_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
9169 if ((this->
getModel()).isModelLinearized()) {
9179:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9182 throw std::runtime_error(
"STXS12_ggHll_pTV250_Inf called with a class whose parent is not NPbase");
9188 double BrHXXRatio = 1.0;
9198 throw std::runtime_error(
"STXS12_ggHll_pTV250_Inf called with invalid argument for final state in fstate_i");
9201 if ((this->
getModel()).isModelLinearized()) {
9211:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9214 throw std::runtime_error(
"STXS12_qqHqq_Nj0 called with a class whose parent is not NPbase");
9220 double BrHXXRatio = 1.0;
9230 throw std::runtime_error(
"STXS12_qqHqq_Nj called with invalid argument for final state in fstate_i");
9233 if ((this->
getModel()).isModelLinearized()) {
9243:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9246 throw std::runtime_error(
"STXS12_qqHqq_Nj1 called with a class whose parent is not NPbase");
9252 double BrHXXRatio = 1.0;
9262 throw std::runtime_error(
"STXS12_qqHqq_Nj1 called with invalid argument for final state in fstate_i");
9265 if ((this->
getModel()).isModelLinearized()) {
9275:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9278 throw std::runtime_error(
"STXS12_qqHqq_mjj0_60_Nj2 called with a class whose parent is not NPbase");
9284 double BrHXXRatio = 1.0;
9294 throw std::runtime_error(
"STXS12_qqHqq_mjj0_60_Nj2 called with invalid argument for final state in fstate_i");
9297 if ((this->
getModel()).isModelLinearized()) {
9311:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9314 throw std::runtime_error(
"STXS12_qqHqq_VH_veto_Nj01 called with a class whose parent is not NPbase");
9321 double weight = 1.0;
9324 double muProd1 = muProd -1.0;
9325 double muProd2 = 0.0;
9328 double BrHXXRatio = 1.0;
9329 double dBrHXXRatio1 = 0.0;
9330 double dBrHXXRatio2 = 0.0;
9336 dBrHXXRatio1 = BrHXXRatio - 1.0;
9340 dBrHXXRatio1 = BrHXXRatio - 1.0;
9344 dBrHXXRatio1 = BrHXXRatio - 1.0;
9348 dBrHXXRatio1 = BrHXXRatio - 1.0;
9352 dBrHXXRatio1 = BrHXXRatio - 1.0;
9356 dBrHXXRatio1 = BrHXXRatio - 1.0;
9360 dBrHXXRatio1 = BrHXXRatio - 1.0;
9363 throw std::runtime_error(
"STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9367 if ((this->
getModel()).isModelLinearized()){
9368 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9369 }
else if((this->
getModel()).isModelNPquadratic()){
9370 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9372 return weight*(muProd)*(BrHXXRatio);
9385:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9388 throw std::runtime_error(
"STXS12_qqHqq_VH_had_Nj2 called with a class whose parent is not NPbase");
9395 double weight = 1.0;
9398 double muProd1 = muProd -1.0;
9399 double muProd2 = 0.0;
9402 double BrHXXRatio = 1.0;
9403 double dBrHXXRatio1 = 0.0;
9404 double dBrHXXRatio2 = 0.0;
9410 dBrHXXRatio1 = BrHXXRatio - 1.0;
9414 dBrHXXRatio1 = BrHXXRatio - 1.0;
9418 dBrHXXRatio1 = BrHXXRatio - 1.0;
9422 dBrHXXRatio1 = BrHXXRatio - 1.0;
9426 dBrHXXRatio1 = BrHXXRatio - 1.0;
9430 dBrHXXRatio1 = BrHXXRatio - 1.0;
9434 dBrHXXRatio1 = BrHXXRatio - 1.0;
9437 throw std::runtime_error(
"STXS12_ggH_pTH200_300 called with invalid argument for final state in fstate_i");
9441 if ((this->
getModel()).isModelLinearized()){
9442 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9443 }
else if((this->
getModel()).isModelNPquadratic()){
9444 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9446 return weight*(muProd)*(BrHXXRatio);
9457:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9460 throw std::runtime_error(
"STXS12_qqHqq_mjj60_120_Nj2 called with a class whose parent is not NPbase");
9467 double weight = 1.0;
9469 double muProd1 = muProd -1.0;
9470 double muProd2 = 0.0;
9473 double BrHXXRatio = 1.0;
9474 double dBrHXXRatio1 = 0.0;
9475 double dBrHXXRatio2 = 0.0;
9481 dBrHXXRatio1 = BrHXXRatio - 1.0;
9485 dBrHXXRatio1 = BrHXXRatio - 1.0;
9489 dBrHXXRatio1 = BrHXXRatio - 1.0;
9493 dBrHXXRatio1 = BrHXXRatio - 1.0;
9497 dBrHXXRatio1 = BrHXXRatio - 1.0;
9501 dBrHXXRatio1 = BrHXXRatio - 1.0;
9505 dBrHXXRatio1 = BrHXXRatio - 1.0;
9508 throw std::runtime_error(
"STXS12_qqHqq_mjj60_120_Nj2 called with invalid argument for final state in fstate_i");
9512 if ((this->
getModel()).isModelLinearized()){
9513 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9514 }
else if((this->
getModel()).isModelNPquadratic()){
9515 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9517 return weight*(muProd)*(BrHXXRatio);
9524:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9527 throw std::runtime_error(
"STXS12_qqHqq_mjj120_350_Nj2 called with a class whose parent is not NPbase");
9533 double BrHXXRatio = 1.0;
9543 throw std::runtime_error(
"STXS12_qqHqq_mjj120_350_Nj2 called with invalid argument for final state in fstate_i");
9546 if ((this->
getModel()).isModelLinearized()) {
9557:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9560 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
9567 double weight = 1.0;
9569 double muProd1 = muProd -1.0;
9570 double muProd2 = 0.0;
9573 double BrHXXRatio = 1.0;
9574 double dBrHXXRatio1 = 0.0;
9575 double dBrHXXRatio2 = 0.0;
9581 dBrHXXRatio1 = BrHXXRatio - 1.0;
9585 dBrHXXRatio1 = BrHXXRatio - 1.0;
9589 dBrHXXRatio1 = BrHXXRatio - 1.0;
9593 dBrHXXRatio1 = BrHXXRatio - 1.0;
9597 dBrHXXRatio1 = BrHXXRatio - 1.0;
9601 dBrHXXRatio1 = BrHXXRatio - 1.0;
9605 dBrHXXRatio1 = BrHXXRatio - 1.0;
9608 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
9613 if ((this->
getModel()).isModelLinearized()){
9614 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9615 }
else if((this->
getModel()).isModelNPquadratic()){
9616 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9618 return weight*(muProd)*(BrHXXRatio);
9632:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9635 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9643 double weight = 1.0;
9645 double muProd1 = muProd -1.0;
9646 double muProd2 = 0.0;
9649 double BrHXXRatio = 1.0;
9650 double dBrHXXRatio1 = 0.0;
9651 double dBrHXXRatio2 = 0.0;
9657 dBrHXXRatio1 = BrHXXRatio - 1.0;
9661 dBrHXXRatio1 = BrHXXRatio - 1.0;
9665 dBrHXXRatio1 = BrHXXRatio - 1.0;
9669 dBrHXXRatio1 = BrHXXRatio - 1.0;
9673 dBrHXXRatio1 = BrHXXRatio - 1.0;
9677 dBrHXXRatio1 = BrHXXRatio - 1.0;
9681 dBrHXXRatio1 = BrHXXRatio - 1.0;
9684 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9688 if ((this->
getModel()).isModelLinearized()){
9689 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9690 }
else if((this->
getModel()).isModelNPquadratic()){
9691 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9693 return weight*(muProd)*(BrHXXRatio);
9707:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9710 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9718 double weight = 1.0;
9720 double muProd1 = muProd -1.0;
9721 double muProd2 = 0.0;
9724 double BrHXXRatio = 1.0;
9725 double dBrHXXRatio1 = 0.0;
9726 double dBrHXXRatio2 = 0.0;
9732 dBrHXXRatio1 = BrHXXRatio - 1.0;
9736 dBrHXXRatio1 = BrHXXRatio - 1.0;
9740 dBrHXXRatio1 = BrHXXRatio - 1.0;
9744 dBrHXXRatio1 = BrHXXRatio - 1.0;
9748 dBrHXXRatio1 = BrHXXRatio - 1.0;
9752 dBrHXXRatio1 = BrHXXRatio - 1.0;
9756 dBrHXXRatio1 = BrHXXRatio - 1.0;
9759 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9763 if ((this->
getModel()).isModelLinearized()){
9764 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9765 }
else if((this->
getModel()).isModelNPquadratic()){
9766 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9768 return weight*(muProd)*(BrHXXRatio);
9778:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9781 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with a class whose parent is not NPbase");
9791 double weight = 1.0;
9793 double muProd1 = muProd -1.0;
9794 double muProd2 = 0.0;
9797 double BrHXXRatio = 1.0;
9798 double dBrHXXRatio1 = 0.0;
9799 double dBrHXXRatio2 = 0.0;
9805 dBrHXXRatio1 = BrHXXRatio - 1.0;
9809 dBrHXXRatio1 = BrHXXRatio - 1.0;
9813 dBrHXXRatio1 = BrHXXRatio - 1.0;
9817 dBrHXXRatio1 = BrHXXRatio - 1.0;
9821 dBrHXXRatio1 = BrHXXRatio - 1.0;
9825 dBrHXXRatio1 = BrHXXRatio - 1.0;
9829 dBrHXXRatio1 = BrHXXRatio - 1.0;
9832 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2 called with invalid argument for final state in fstate_i");
9836 if ((this->
getModel()).isModelLinearized()){
9837 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9838 }
else if((this->
getModel()).isModelNPquadratic()){
9839 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9841 return weight*(muProd)*(BrHXXRatio);
9852:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9855 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9867 double weight = 1.0;
9869 double muProd1 = muProd -1.0;
9870 double muProd2 = 0.0;
9873 double BrHXXRatio = 1.0;
9874 double dBrHXXRatio1 = 0.0;
9875 double dBrHXXRatio2 = 0.0;
9881 dBrHXXRatio1 = BrHXXRatio - 1.0;
9885 dBrHXXRatio1 = BrHXXRatio - 1.0;
9889 dBrHXXRatio1 = BrHXXRatio - 1.0;
9893 dBrHXXRatio1 = BrHXXRatio - 1.0;
9897 dBrHXXRatio1 = BrHXXRatio - 1.0;
9901 dBrHXXRatio1 = BrHXXRatio - 1.0;
9905 dBrHXXRatio1 = BrHXXRatio - 1.0;
9908 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9912 if ((this->
getModel()).isModelLinearized()){
9913 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
9914 }
else if((this->
getModel()).isModelNPquadratic()){
9915 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
9917 return weight*(muProd)*(BrHXXRatio);
9938:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
9941 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with a class whose parent is not NPbase");
9951 double weight = 1.0;
9955 )/(0.175166+0.1647);
9956 double muProd1 = muProd -1.0;
9957 double muProd2 = 0.0;
9960 double BrHXXRatio = 1.0;
9961 double dBrHXXRatio1 = 0.0;
9962 double dBrHXXRatio2 = 0.0;
9968 dBrHXXRatio1 = BrHXXRatio - 1.0;
9972 dBrHXXRatio1 = BrHXXRatio - 1.0;
9976 dBrHXXRatio1 = BrHXXRatio - 1.0;
9980 dBrHXXRatio1 = BrHXXRatio - 1.0;
9984 dBrHXXRatio1 = BrHXXRatio - 1.0;
9988 dBrHXXRatio1 = BrHXXRatio - 1.0;
9992 dBrHXXRatio1 = BrHXXRatio - 1.0;
9995 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2 called with invalid argument for final state in fstate_i");
9999 if ((this->
getModel()).isModelLinearized()){
10000 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10001 }
else if((this->
getModel()).isModelNPquadratic()){
10002 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10004 return weight*(muProd)*(BrHXXRatio);
10021:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10024 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10031 double weight = 1.0;
10033 double muProd1 = muProd -1.0;
10034 double muProd2 = 0.0;
10037 double BrHXXRatio = 1.0;
10038 double dBrHXXRatio1 = 0.0;
10039 double dBrHXXRatio2 = 0.0;
10043 }
else if (
fstate == 1){
10045 dBrHXXRatio1 = BrHXXRatio - 1.0;
10046 dBrHXXRatio2 = 0.0;
10047 }
else if (
fstate == 2){
10049 dBrHXXRatio1 = BrHXXRatio - 1.0;
10050 dBrHXXRatio2 = 0.0;
10051 }
else if (
fstate == 3){
10053 dBrHXXRatio1 = BrHXXRatio - 1.0;
10054 dBrHXXRatio2 = 0.0;
10055 }
else if (
fstate == 4){
10057 dBrHXXRatio1 = BrHXXRatio - 1.0;
10058 dBrHXXRatio2 = 0.0;
10059 }
else if (
fstate == 5){
10061 dBrHXXRatio1 = BrHXXRatio - 1.0;
10062 dBrHXXRatio2 = 0.0;
10063 }
else if (
fstate == 6){
10065 dBrHXXRatio1 = BrHXXRatio - 1.0;
10066 dBrHXXRatio2 = 0.0;
10067 }
else if (
fstate == 7){
10069 dBrHXXRatio1 = BrHXXRatio - 1.0;
10070 dBrHXXRatio2 = 0.0;
10072 throw std::runtime_error(
"STXS12_qqHqq_mjj350_700_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10076 if ((this->
getModel()).isModelLinearized()){
10077 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10078 }
else if((this->
getModel()).isModelNPquadratic()){
10079 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10081 return weight*(muProd)*(BrHXXRatio);
10091:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10094 throw std::runtime_error(
"STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10101 double weight = 1.0;
10103 double muProd1 = muProd -1.0;
10104 double muProd2 = 0.0;
10107 double BrHXXRatio = 1.0;
10108 double dBrHXXRatio1 = 0.0;
10109 double dBrHXXRatio2 = 0.0;
10113 }
else if (
fstate == 1){
10115 dBrHXXRatio1 = BrHXXRatio - 1.0;
10116 dBrHXXRatio2 = 0.0;
10117 }
else if (
fstate == 2){
10119 dBrHXXRatio1 = BrHXXRatio - 1.0;
10120 dBrHXXRatio2 = 0.0;
10121 }
else if (
fstate == 3){
10123 dBrHXXRatio1 = BrHXXRatio - 1.0;
10124 dBrHXXRatio2 = 0.0;
10125 }
else if (
fstate == 4){
10127 dBrHXXRatio1 = BrHXXRatio - 1.0;
10128 dBrHXXRatio2 = 0.0;
10129 }
else if (
fstate == 5){
10131 dBrHXXRatio1 = BrHXXRatio - 1.0;
10132 dBrHXXRatio2 = 0.0;
10133 }
else if (
fstate == 6){
10135 dBrHXXRatio1 = BrHXXRatio - 1.0;
10136 dBrHXXRatio2 = 0.0;
10137 }
else if (
fstate == 7){
10139 dBrHXXRatio1 = BrHXXRatio - 1.0;
10140 dBrHXXRatio2 = 0.0;
10142 throw std::runtime_error(
"STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10146 if ((this->
getModel()).isModelLinearized()){
10147 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10148 }
else if((this->
getModel()).isModelNPquadratic()){
10149 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10151 return weight*(muProd)*(BrHXXRatio);
10161:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10164 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10171 double weight = 1.0;
10173 double muProd1 = muProd -1.0;
10174 double muProd2 = 0.0;
10177 double BrHXXRatio = 1.0;
10178 double dBrHXXRatio1 = 0.0;
10179 double dBrHXXRatio2 = 0.0;
10183 }
else if (
fstate == 1){
10185 dBrHXXRatio1 = BrHXXRatio - 1.0;
10186 dBrHXXRatio2 = 0.0;
10187 }
else if (
fstate == 2){
10189 dBrHXXRatio1 = BrHXXRatio - 1.0;
10190 dBrHXXRatio2 = 0.0;
10191 }
else if (
fstate == 3){
10193 dBrHXXRatio1 = BrHXXRatio - 1.0;
10194 dBrHXXRatio2 = 0.0;
10195 }
else if (
fstate == 4){
10197 dBrHXXRatio1 = BrHXXRatio - 1.0;
10198 dBrHXXRatio2 = 0.0;
10199 }
else if (
fstate == 5){
10201 dBrHXXRatio1 = BrHXXRatio - 1.0;
10202 dBrHXXRatio2 = 0.0;
10203 }
else if (
fstate == 6){
10205 dBrHXXRatio1 = BrHXXRatio - 1.0;
10206 dBrHXXRatio2 = 0.0;
10207 }
else if (
fstate == 7){
10209 dBrHXXRatio1 = BrHXXRatio - 1.0;
10210 dBrHXXRatio2 = 0.0;
10212 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10216 if ((this->
getModel()).isModelLinearized()){
10217 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10218 }
else if((this->
getModel()).isModelNPquadratic()){
10219 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10221 return weight*(muProd)*(BrHXXRatio);
10231:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10234 throw std::runtime_error(
"STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10241 double weight = 1.0;
10243 double muProd1 = muProd -1.0;
10244 double muProd2 = 0.0;
10247 double BrHXXRatio = 1.0;
10248 double dBrHXXRatio1 = 0.0;
10249 double dBrHXXRatio2 = 0.0;
10253 }
else if (
fstate == 1){
10255 dBrHXXRatio1 = BrHXXRatio - 1.0;
10256 dBrHXXRatio2 = 0.0;
10257 }
else if (
fstate == 2){
10259 dBrHXXRatio1 = BrHXXRatio - 1.0;
10260 dBrHXXRatio2 = 0.0;
10261 }
else if (
fstate == 3){
10263 dBrHXXRatio1 = BrHXXRatio - 1.0;
10264 dBrHXXRatio2 = 0.0;
10265 }
else if (
fstate == 4){
10267 dBrHXXRatio1 = BrHXXRatio - 1.0;
10268 dBrHXXRatio2 = 0.0;
10269 }
else if (
fstate == 5){
10271 dBrHXXRatio1 = BrHXXRatio - 1.0;
10272 dBrHXXRatio2 = 0.0;
10273 }
else if (
fstate == 6){
10275 dBrHXXRatio1 = BrHXXRatio - 1.0;
10276 dBrHXXRatio2 = 0.0;
10277 }
else if (
fstate == 7){
10279 dBrHXXRatio1 = BrHXXRatio - 1.0;
10280 dBrHXXRatio2 = 0.0;
10282 throw std::runtime_error(
"STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10286 if ((this->
getModel()).isModelLinearized()){
10287 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10288 }
else if((this->
getModel()).isModelNPquadratic()){
10289 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10291 return weight*(muProd)*(BrHXXRatio);
10300:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10303 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10310 double weight = 1.0;
10315 ) / (0.22408+0.21578);
10316 double muProd1 = muProd - 1.0;
10317 double muProd2 = 0.0;
10320 double BrHXXRatio = 1.0;
10321 double dBrHXXRatio1 = 0.0;
10322 double dBrHXXRatio2 = 0.0;
10325 weight = (0.22408+0.21578) ;
10326 }
else if (
fstate == 1){
10328 dBrHXXRatio1 = BrHXXRatio - 1.0;
10329 dBrHXXRatio2 = 0.0;
10330 }
else if (
fstate == 2){
10332 dBrHXXRatio1 = BrHXXRatio - 1.0;
10333 dBrHXXRatio2 = 0.0;
10334 }
else if (
fstate == 3){
10336 dBrHXXRatio1 = BrHXXRatio - 1.0;
10337 dBrHXXRatio2 = 0.0;
10338 }
else if (
fstate == 4){
10340 dBrHXXRatio1 = BrHXXRatio - 1.0;
10341 dBrHXXRatio2 = 0.0;
10342 }
else if (
fstate == 5){
10344 dBrHXXRatio1 = BrHXXRatio - 1.0;
10345 dBrHXXRatio2 = 0.0;
10346 }
else if (
fstate == 6){
10348 dBrHXXRatio1 = BrHXXRatio - 1.0;
10349 dBrHXXRatio2 = 0.0;
10350 }
else if (
fstate == 7){
10352 dBrHXXRatio1 = BrHXXRatio - 1.0;
10353 dBrHXXRatio2 = 0.0;
10355 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10359 if ((this->
getModel()).isModelLinearized()){
10360 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10361 }
else if((this->
getModel()).isModelNPquadratic()){
10362 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10364 return weight*(muProd)*(BrHXXRatio);
10376:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10379 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2 called with a class whose parent is not NPbase");
10386 double weight = 1.0;
10392 )/(0.25614+0.22408+0.21578);
10393 double muProd1 = (muProd-1.0);
10394 double muProd2 = 0.0;
10397 double BrHXXRatio = 1.0;
10398 double dBrHXXRatio1 = 0.0;
10399 double dBrHXXRatio2 = 0.0;
10402 weight = (0.25614+0.22408+0.21578);
10403 }
else if (
fstate == 1){
10405 dBrHXXRatio1 = BrHXXRatio - 1.0;
10406 dBrHXXRatio2 = 0.0;
10407 }
else if (
fstate == 2){
10409 dBrHXXRatio1 = BrHXXRatio - 1.0;
10410 dBrHXXRatio2 = 0.0;
10411 }
else if (
fstate == 3){
10413 dBrHXXRatio1 = BrHXXRatio - 1.0;
10414 dBrHXXRatio2 = 0.0;
10415 }
else if (
fstate == 4){
10417 dBrHXXRatio1 = BrHXXRatio - 1.0;
10418 dBrHXXRatio2 = 0.0;
10419 }
else if (
fstate == 5){
10421 dBrHXXRatio1 = BrHXXRatio - 1.0;
10422 dBrHXXRatio2 = 0.0;
10423 }
else if (
fstate == 6){
10425 dBrHXXRatio1 = BrHXXRatio - 1.0;
10426 dBrHXXRatio2 = 0.0;
10427 }
else if (
fstate == 7){
10429 dBrHXXRatio1 = BrHXXRatio - 1.0;
10430 dBrHXXRatio2 = 0.0;
10432 throw std::runtime_error(
"STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2 called with invalid argument for final state in fstate_i");
10436 if ((this->
getModel()).isModelLinearized()){
10437 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10438 }
else if((this->
getModel()).isModelNPquadratic()){
10439 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10441 return weight*(muProd)*(BrHXXRatio);
10454:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10457 throw std::runtime_error(
"STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
10464 double weight = 1.0;
10466 double muProd1 = muProd -1.0;
10467 double muProd2 = 0.0;
10470 double BrHXXRatio = 1.0;
10471 double dBrHXXRatio1 = 0.0;
10472 double dBrHXXRatio2 = 0.0;
10476 }
else if (
fstate == 1){
10478 dBrHXXRatio1 = BrHXXRatio - 1.0;
10479 dBrHXXRatio2 = 0.0;
10480 }
else if (
fstate == 2){
10482 dBrHXXRatio1 = BrHXXRatio - 1.0;
10483 dBrHXXRatio2 = 0.0;
10484 }
else if (
fstate == 3){
10486 dBrHXXRatio1 = BrHXXRatio - 1.0;
10487 dBrHXXRatio2 = 0.0;
10488 }
else if (
fstate == 4){
10490 dBrHXXRatio1 = BrHXXRatio - 1.0;
10491 dBrHXXRatio2 = 0.0;
10493 throw std::runtime_error(
"STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
10497 if ((this->
getModel()).isModelLinearized()){
10498 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10499 }
else if((this->
getModel()).isModelNPquadratic()){
10500 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10502 return weight*(muProd)*(BrHXXRatio);
10512:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10515 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with a class whose parent is not NPbase");
10522 double weight = 1.0;
10524 double muProd1 = muProd -1.0;
10525 double muProd2 = 0.0;
10528 double BrHXXRatio = 1.0;
10529 double dBrHXXRatio1 = 0.0;
10530 double dBrHXXRatio2 = 0.0;
10534 }
else if (
fstate == 1){
10536 dBrHXXRatio1 = BrHXXRatio - 1.0;
10537 dBrHXXRatio2 = 0.0;
10538 }
else if (
fstate == 2){
10540 dBrHXXRatio1 = BrHXXRatio - 1.0;
10541 dBrHXXRatio2 = 0.0;
10542 }
else if (
fstate == 3){
10544 dBrHXXRatio1 = BrHXXRatio - 1.0;
10545 dBrHXXRatio2 = 0.0;
10546 }
else if (
fstate == 4){
10548 dBrHXXRatio1 = BrHXXRatio - 1.0;
10549 dBrHXXRatio2 = 0.0;
10551 throw std::runtime_error(
"STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2 called with invalid argument for final state in fstate_i");
10555 if ((this->
getModel()).isModelLinearized()){
10556 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10557 }
else if((this->
getModel()).isModelNPquadratic()){
10558 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10560 return weight*(muProd)*(BrHXXRatio);
10569:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10572 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_Nj2 called with a class whose parent is not NPbase");
10579 double weight = 1.0;
10589 / (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315) ;
10591 double muProd1 = muProd - 1.;
10592 double muProd2 = 0.0;
10595 double BrHXXRatio = 1.0;
10596 double dBrHXXRatio1 = 0.0;
10597 double dBrHXXRatio2 = 0.0;
10600 weight = (0.53537+0.25614+0.22408+0.21578+0.073727+0.07315);
10601 }
else if (
fstate == 1){
10603 dBrHXXRatio1 = BrHXXRatio - 1.0;
10604 dBrHXXRatio2 = 0.0;
10605 }
else if (
fstate == 2){
10607 dBrHXXRatio1 = BrHXXRatio - 1.0;
10608 dBrHXXRatio2 = 0.0;
10609 }
else if (
fstate == 3){
10611 dBrHXXRatio1 = BrHXXRatio - 1.0;
10612 dBrHXXRatio2 = 0.0;
10613 }
else if (
fstate == 4){
10615 dBrHXXRatio1 = BrHXXRatio - 1.0;
10616 dBrHXXRatio2 = 0.0;
10617 }
else if (
fstate == 5){
10619 dBrHXXRatio1 = BrHXXRatio - 1.0;
10620 dBrHXXRatio2 = 0.0;
10622 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10629 if ((this->
getModel()).isModelLinearized()){
10631 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10632 }
else if((this->
getModel()).isModelNPquadratic()){
10634 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10637 return weight*(muProd)*(BrHXXRatio);
10645:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10648 throw std::runtime_error(
"STXS12_qqHlv_pTV0_75 called with a class whose parent is not NPbase");
10655 double weight = 1.0;
10657 double muProd1 = muProd -1.0;
10658 double muProd2 = 0.0;
10661 double BrHXXRatio = 1.0;
10662 double dBrHXXRatio1 = 0.0;
10663 double dBrHXXRatio2 = 0.0;
10667 }
else if (
fstate == 1){
10669 dBrHXXRatio1 = BrHXXRatio - 1.0;
10670 dBrHXXRatio2 = 0.0;
10671 }
else if (
fstate == 2){
10673 dBrHXXRatio1 = BrHXXRatio - 1.0;
10674 dBrHXXRatio2 = 0.0;
10675 }
else if (
fstate == 3){
10677 dBrHXXRatio1 = BrHXXRatio - 1.0;
10678 dBrHXXRatio2 = 0.0;
10679 }
else if (
fstate == 4){
10681 dBrHXXRatio1 = BrHXXRatio - 1.0;
10682 dBrHXXRatio2 = 0.0;
10683 }
else if (
fstate == 5){
10685 dBrHXXRatio1 = BrHXXRatio - 1.0;
10686 dBrHXXRatio2 = 0.0;
10688 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10692 if ((this->
getModel()).isModelLinearized()){
10693 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10694 }
else if((this->
getModel()).isModelNPquadratic()){
10695 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10697 return weight*(muProd)*(BrHXXRatio);
10705:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10708 throw std::runtime_error(
"STXS12_qqHlv_pTV75_150 called with a class whose parent is not NPbase");
10715 double weight = 1.0;
10717 double muProd1 = muProd -1.0;
10718 double muProd2 = 0.0;
10721 double BrHXXRatio = 1.0;
10722 double dBrHXXRatio1 = 0.0;
10723 double dBrHXXRatio2 = 0.0;
10727 }
else if (
fstate == 1){
10729 dBrHXXRatio1 = BrHXXRatio - 1.0;
10730 dBrHXXRatio2 = 0.0;
10731 }
else if (
fstate == 2){
10733 dBrHXXRatio1 = BrHXXRatio - 1.0;
10734 dBrHXXRatio2 = 0.0;
10735 }
else if (
fstate == 3){
10737 dBrHXXRatio1 = BrHXXRatio - 1.0;
10738 dBrHXXRatio2 = 0.0;
10739 }
else if (
fstate == 4){
10741 dBrHXXRatio1 = BrHXXRatio - 1.0;
10742 dBrHXXRatio2 = 0.0;
10743 }
else if (
fstate == 5){
10745 dBrHXXRatio1 = BrHXXRatio - 1.0;
10746 dBrHXXRatio2 = 0.0;
10748 throw std::runtime_error(
"STXS12_qqHlv_pTV75_150 called with invalid argument for final state in fstate_i");
10752 if ((this->
getModel()).isModelLinearized()){
10753 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10754 }
else if((this->
getModel()).isModelNPquadratic()){
10755 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10757 return weight*(muProd)*(BrHXXRatio);
10766:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10769 throw std::runtime_error(
"STXS12_qqHlv_pTV150_250_Nj0 called with a class whose parent is not NPbase");
10776 double weight = 1.0;
10779 double muProd2 = 0.0;
10782 double BrHXXRatio = 1.0;
10783 double dBrHXXRatio1 = 0.0;
10784 double dBrHXXRatio2 = 0.0;
10788 }
else if (
fstate == 1){
10790 dBrHXXRatio1 = BrHXXRatio - 1.0;
10791 dBrHXXRatio2 = 0.0;
10792 }
else if (
fstate == 2){
10794 dBrHXXRatio1 = BrHXXRatio - 1.0;
10795 dBrHXXRatio2 = 0.0;
10796 }
else if (
fstate == 3){
10798 dBrHXXRatio1 = BrHXXRatio - 1.0;
10799 dBrHXXRatio2 = 0.0;
10800 }
else if (
fstate == 4){
10802 dBrHXXRatio1 = BrHXXRatio - 1.0;
10803 dBrHXXRatio2 = 0.0;
10804 }
else if (
fstate == 5){
10806 dBrHXXRatio1 = BrHXXRatio - 1.0;
10807 dBrHXXRatio2 = 0.0;
10809 throw std::runtime_error(
"STXS12_qqHqq_mjj350_Inf_Nj2 called with invalid argument for final state in fstate_i");
10813 if ((this->
getModel()).isModelLinearized()){
10814 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10815 }
else if((this->
getModel()).isModelNPquadratic()){
10816 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10818 return weight*(muProd)*(BrHXXRatio);
10832:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10835 throw std::runtime_error(
"STXS12_qqHlv_pTV150_250_Nj1 called with a class whose parent is not NPbase");
10841 double BrHXXRatio = 1.0;
10844 }
else if (
fstate == 2){
10846 }
else if (
fstate == 3){
10848 }
else if (
fstate == 4){
10851 throw std::runtime_error(
"STXS12_qqHlv_pTV150_250_Nj1 called with invalid argument for final state in fstate_i");
10854 if ((this->
getModel()).isModelLinearized()) {
10864:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10867 throw std::runtime_error(
"STXS12_qqHlv_pTV250_Inf called with a class whose parent is not NPbase");
10875 double weight = 1.0;
10879 double muProd1 = (muProd -1.);
10880 double muProd2 = 0.0;
10883 double BrHXXRatio = 1.0;
10884 double dBrHXXRatio1 = 0.0;
10885 double dBrHXXRatio2 = 0.0;
10888 weight = (0.01127+0.00339) ;
10889 }
else if (
fstate == 1){
10891 dBrHXXRatio1 = BrHXXRatio - 1.0;
10892 dBrHXXRatio2 = 0.0;
10893 }
else if (
fstate == 2){
10895 dBrHXXRatio1 = BrHXXRatio - 1.0;
10896 dBrHXXRatio2 = 0.0;
10897 }
else if (
fstate == 3){
10899 dBrHXXRatio1 = BrHXXRatio - 1.0;
10900 dBrHXXRatio2 = 0.0;
10901 }
else if (
fstate == 4){
10903 dBrHXXRatio1 = BrHXXRatio - 1.0;
10904 dBrHXXRatio2 = 0.0;
10905 }
else if (
fstate == 5){
10907 dBrHXXRatio1 = BrHXXRatio - 1.0;
10908 dBrHXXRatio2 = 0.0;
10909 }
else if (
fstate == 6){
10911 dBrHXXRatio1 = BrHXXRatio - 1.0;
10912 dBrHXXRatio2 = 0.0;
10913 }
else if (
fstate == 7){
10915 dBrHXXRatio1 = BrHXXRatio - 1.0;
10916 dBrHXXRatio2 = 0.0;
10918 throw std::runtime_error(
"STXS12_qqHlv_pTV250_Inf called with invalid argument for final state in fstate_i");
10922 if ((this->
getModel()).isModelLinearized()){
10923 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10924 }
else if((this->
getModel()).isModelNPquadratic()){
10925 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
10927 return weight*(muProd)*(BrHXXRatio);
10937:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
10940 throw std::runtime_error(
"STXS12_qqHlv_pTV0_150 called with a class whose parent is not NPbase");
10947 double weight = 1.0;
10954 double muProd2 = 0.0;
10957 double BrHXXRatio = 1.0;
10958 double dBrHXXRatio1 = 0.0;
10959 double dBrHXXRatio2 = 0.0;
10962 weight = (0.21509+0.13440) ;
10963 }
else if (
fstate == 1){
10965 dBrHXXRatio1 = BrHXXRatio - 1.0;
10966 dBrHXXRatio2 = 0.0;
10967 }
else if (
fstate == 2){
10969 dBrHXXRatio1 = BrHXXRatio - 1.0;
10970 dBrHXXRatio2 = 0.0;
10971 }
else if (
fstate == 3){
10973 dBrHXXRatio1 = BrHXXRatio - 1.0;
10974 dBrHXXRatio2 = 0.0;
10975 }
else if (
fstate == 4){
10977 dBrHXXRatio1 = BrHXXRatio - 1.0;
10978 dBrHXXRatio2 = 0.0;
10979 }
else if (
fstate == 5){
10981 dBrHXXRatio1 = BrHXXRatio - 1.0;
10982 dBrHXXRatio2 = 0.0;
10983 }
else if (
fstate == 6){
10985 dBrHXXRatio1 = BrHXXRatio - 1.0;
10986 dBrHXXRatio2 = 0.0;
10987 }
else if (
fstate == 7){
10989 dBrHXXRatio1 = BrHXXRatio - 1.0;
10990 dBrHXXRatio2 = 0.0;
10992 throw std::runtime_error(
"STXS12_qqHlv_pTV0_150 called with invalid argument for final state in fstate_i");
10996 if ((this->
getModel()).isModelLinearized()){
10997 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
10998 }
else if((this->
getModel()).isModelNPquadratic()){
10999 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11001 return weight*(muProd)*(BrHXXRatio);
11011:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11014 throw std::runtime_error(
"STXS12_qqHlv_pTV150_Inf called with a class whose parent is not NPbase");
11021 double weight = 1.0;
11030 double muProd2 = 0.0;
11033 double BrHXXRatio = 1.0;
11034 double dBrHXXRatio1 = 0.0;
11035 double dBrHXXRatio2 = 0.0;
11038 weight = (0.04117+0.01004+0.00214) ;
11039 }
else if (
fstate == 1){
11041 dBrHXXRatio1 = BrHXXRatio - 1.0;
11042 dBrHXXRatio2 = 0.0;
11043 }
else if (
fstate == 2){
11045 dBrHXXRatio1 = BrHXXRatio - 1.0;
11046 dBrHXXRatio2 = 0.0;
11047 }
else if (
fstate == 3){
11049 dBrHXXRatio1 = BrHXXRatio - 1.0;
11050 dBrHXXRatio2 = 0.0;
11051 }
else if (
fstate == 4){
11053 dBrHXXRatio1 = BrHXXRatio - 1.0;
11054 dBrHXXRatio2 = 0.0;
11055 }
else if (
fstate == 5){
11057 dBrHXXRatio1 = BrHXXRatio - 1.0;
11058 dBrHXXRatio2 = 0.0;
11059 }
else if (
fstate == 6){
11061 dBrHXXRatio1 = BrHXXRatio - 1.0;
11062 dBrHXXRatio2 = 0.0;
11063 }
else if (
fstate == 7){
11065 dBrHXXRatio1 = BrHXXRatio - 1.0;
11066 dBrHXXRatio2 = 0.0;
11068 throw std::runtime_error(
"STXS12_qqHlv_pTV150_Inf called with invalid argument for final state in fstate_i");
11072 if ((this->
getModel()).isModelLinearized()){
11073 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11074 }
else if((this->
getModel()).isModelNPquadratic()){
11075 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11077 return weight*(muProd)*(BrHXXRatio);
11087:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11090 throw std::runtime_error(
"STXS12_qqHlv_pTV250_400 called with a class whose parent is not NPbase");
11097 double weight = 1.0;
11100 double muProd2 = 0.0;
11103 double BrHXXRatio = 1.0;
11104 double dBrHXXRatio1 = 0.0;
11105 double dBrHXXRatio2 = 0.0;
11109 }
else if (
fstate == 1){
11111 dBrHXXRatio1 = BrHXXRatio - 1.0;
11112 dBrHXXRatio2 = 0.0;
11113 }
else if (
fstate == 2){
11115 dBrHXXRatio1 = BrHXXRatio - 1.0;
11116 dBrHXXRatio2 = 0.0;
11117 }
else if (
fstate == 3){
11119 dBrHXXRatio1 = BrHXXRatio - 1.0;
11120 dBrHXXRatio2 = 0.0;
11121 }
else if (
fstate == 4){
11123 dBrHXXRatio1 = BrHXXRatio - 1.0;
11124 dBrHXXRatio2 = 0.0;
11126 throw std::runtime_error(
"STXS12_qqHlv_pTV250_400 called with invalid argument for final state in fstate_i");
11130 if ((this->
getModel()).isModelLinearized()){
11131 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11132 }
else if((this->
getModel()).isModelNPquadratic()){
11133 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11135 return weight*(muProd)*(BrHXXRatio);
11145:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11148 throw std::runtime_error(
"STXS12_qqHlv_pTV400_Inf called with a class whose parent is not NPbase");
11155 double weight = 1.0;
11157 double muProd1 = muProd-1.0 ;
11158 double muProd2 = 0.0;
11161 double BrHXXRatio = 1.0;
11162 double dBrHXXRatio1 = 0.0;
11163 double dBrHXXRatio2 = 0.0;
11167 }
else if (
fstate == 1){
11169 dBrHXXRatio1 = BrHXXRatio - 1.0;
11170 dBrHXXRatio2 = 0.0;
11171 }
else if (
fstate == 2){
11173 dBrHXXRatio1 = BrHXXRatio - 1.0;
11174 dBrHXXRatio2 = 0.0;
11175 }
else if (
fstate == 3){
11177 dBrHXXRatio1 = BrHXXRatio - 1.0;
11178 dBrHXXRatio2 = 0.0;
11179 }
else if (
fstate == 4){
11181 dBrHXXRatio1 = BrHXXRatio - 1.0;
11182 dBrHXXRatio2 = 0.0;
11184 throw std::runtime_error(
"STXS12_qqHlv_pTV400_Inf called with invalid argument for final state in fstate_i");
11188 if ((this->
getModel()).isModelLinearized()){
11189 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11190 }
else if((this->
getModel()).isModelNPquadratic()){
11191 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11193 return weight*(muProd)*(BrHXXRatio);
11203:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11206 throw std::runtime_error(
"STXS12_qqHll_pTV0_75 called with a class whose parent is not NPbase");
11212 double BrHXXRatio = 1.0;
11215 }
else if (
fstate == 2){
11217 }
else if (
fstate == 3){
11219 }
else if (
fstate == 4){
11222 throw std::runtime_error(
"STXS12_qqHll_pTV0_75 called with invalid argument for final state in fstate_i");
11225 if ((this->
getModel()).isModelLinearized()) {
11236:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11239 throw std::runtime_error(
"STXS12_qqHll_pTV75_150 called with a class whose parent is not NPbase");
11246 double weight = 1.0;
11248 double muProd1 = muProd -1.0;
11249 double muProd2 = 0.0;
11252 double BrHXXRatio = 1.0;
11253 double dBrHXXRatio1 = 0.0;
11254 double dBrHXXRatio2 = 0.0;
11258 }
else if (
fstate == 1){
11260 dBrHXXRatio1 = BrHXXRatio - 1.0;
11261 dBrHXXRatio2 = 0.0;
11262 }
else if (
fstate == 2){
11264 dBrHXXRatio1 = BrHXXRatio - 1.0;
11265 dBrHXXRatio2 = 0.0;
11266 }
else if (
fstate == 3){
11268 dBrHXXRatio1 = BrHXXRatio - 1.0;
11269 dBrHXXRatio2 = 0.0;
11270 }
else if (
fstate == 4){
11272 dBrHXXRatio1 = BrHXXRatio - 1.0;
11273 dBrHXXRatio2 = 0.0;
11275 throw std::runtime_error(
"STXS12_qqHll_pTV75_150 called with invalid argument for final state in fstate_i");
11279 if ((this->
getModel()).isModelLinearized()){
11280 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11281 }
else if((this->
getModel()).isModelNPquadratic()){
11282 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11284 return weight*(muProd)*(BrHXXRatio);
11294:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11297 throw std::runtime_error(
"STXS12_qqHll_pTV150_250_Nj0 called with a class whose parent is not NPbase");
11304 double weight = 1.0;
11306 double muProd1 = muProd -1.0;
11307 double muProd2 = 0.0;
11310 double BrHXXRatio = 1.0;
11311 double dBrHXXRatio1 = 0.0;
11312 double dBrHXXRatio2 = 0.0;
11316 }
else if (
fstate == 1){
11318 dBrHXXRatio1 = BrHXXRatio - 1.0;
11319 dBrHXXRatio2 = 0.0;
11320 }
else if (
fstate == 2){
11322 dBrHXXRatio1 = BrHXXRatio - 1.0;
11323 dBrHXXRatio2 = 0.0;
11324 }
else if (
fstate == 3){
11326 dBrHXXRatio1 = BrHXXRatio - 1.0;
11327 dBrHXXRatio2 = 0.0;
11328 }
else if (
fstate == 4){
11330 dBrHXXRatio1 = BrHXXRatio - 1.0;
11331 dBrHXXRatio2 = 0.0;
11333 throw std::runtime_error(
"STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
11337 if ((this->
getModel()).isModelLinearized()){
11338 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11339 }
else if((this->
getModel()).isModelNPquadratic()){
11340 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11342 return weight*(muProd)*(BrHXXRatio);
11350:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11353 throw std::runtime_error(
"STXS12_qqHll_pTV150_250_Nj1 called with a class whose parent is not NPbase");
11361 double weight = 1.0;
11363 double muProd1 = muProd -1.0;
11364 double muProd2 = 0.0;
11367 double BrHXXRatio = 1.0;
11368 double dBrHXXRatio1 = 0.0;
11369 double dBrHXXRatio2 = 0.0;
11372 weight = (0.0168) ;
11373 }
else if (
fstate == 1){
11375 dBrHXXRatio1 = BrHXXRatio - 1.0;
11376 dBrHXXRatio2 = 0.0;
11377 }
else if (
fstate == 2){
11379 dBrHXXRatio1 = BrHXXRatio - 1.0;
11380 dBrHXXRatio2 = 0.0;
11381 }
else if (
fstate == 3){
11383 dBrHXXRatio1 = BrHXXRatio - 1.0;
11384 dBrHXXRatio2 = 0.0;
11385 }
else if (
fstate == 4){
11387 dBrHXXRatio1 = BrHXXRatio - 1.0;
11388 dBrHXXRatio2 = 0.0;
11390 throw std::runtime_error(
"STXS12_qqHll_pTV150_250_Nj0 called with invalid argument for final state in fstate_i");
11394 if ((this->
getModel()).isModelLinearized()){
11395 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11396 }
else if((this->
getModel()).isModelNPquadratic()){
11397 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11399 return weight*(muProd)*(BrHXXRatio);
11411:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11414 throw std::runtime_error(
"STXS12_qqHll_pTV250_Inf called with a class whose parent is not NPbase");
11420 double BrHXXRatio = 1.0;
11423 }
else if (
fstate == 2){
11425 }
else if (
fstate == 3){
11427 }
else if (
fstate == 4){
11430 throw std::runtime_error(
"STXS12_qqHll_pTV250_Inf called with invalid argument for final state in fstate_i");
11433 if ((this->
getModel()).isModelLinearized()) {
11445:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11448 throw std::runtime_error(
"STXS12_qqHll_pTV0_150 called with a class whose parent is not NPbase");
11455 double weight = 1.0;
11457 double muProd1 = muProd -1.0;
11458 double muProd2 = 0.0;
11461 double BrHXXRatio = 1.0;
11462 double dBrHXXRatio1 = 0.0;
11463 double dBrHXXRatio2 = 0.0;
11467 }
else if (
fstate == 1){
11469 dBrHXXRatio1 = BrHXXRatio - 1.0;
11470 dBrHXXRatio2 = 0.0;
11471 }
else if (
fstate == 2){
11473 dBrHXXRatio1 = BrHXXRatio - 1.0;
11474 dBrHXXRatio2 = 0.0;
11475 }
else if (
fstate == 3){
11477 dBrHXXRatio1 = BrHXXRatio - 1.0;
11478 dBrHXXRatio2 = 0.0;
11479 }
else if (
fstate == 4){
11481 dBrHXXRatio1 = BrHXXRatio - 1.0;
11482 dBrHXXRatio2 = 0.0;
11483 }
else if (
fstate == 5){
11485 dBrHXXRatio1 = BrHXXRatio - 1.0;
11486 dBrHXXRatio2 = 0.0;
11487 }
else if (
fstate == 6){
11489 dBrHXXRatio1 = BrHXXRatio - 1.0;
11490 dBrHXXRatio2 = 0.0;
11491 }
else if (
fstate == 7){
11493 dBrHXXRatio1 = BrHXXRatio - 1.0;
11494 dBrHXXRatio2 = 0.0;
11496 throw std::runtime_error(
"STXS12_qqHll_pTV0_150 called with invalid argument for final state in fstate_i");
11500 if ((this->
getModel()).isModelLinearized()){
11501 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11502 }
else if((this->
getModel()).isModelNPquadratic()){
11503 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11505 return weight*(muProd)*(BrHXXRatio);
11514:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11517 throw std::runtime_error(
"STXS12_qqHll_pTV250_400 called with a class whose parent is not NPbase");
11524 double weight = 1.0;
11526 double muProd1 = muProd -1.0;
11527 double muProd2 = 0.0;
11530 double BrHXXRatio = 1.0;
11531 double dBrHXXRatio1 = 0.0;
11532 double dBrHXXRatio2 = 0.0;
11536 }
else if (
fstate == 1){
11538 dBrHXXRatio1 = BrHXXRatio - 1.0;
11539 dBrHXXRatio2 = 0.0;
11540 }
else if (
fstate == 2){
11542 dBrHXXRatio1 = BrHXXRatio - 1.0;
11543 dBrHXXRatio2 = 0.0;
11544 }
else if (
fstate == 3){
11546 dBrHXXRatio1 = BrHXXRatio - 1.0;
11547 dBrHXXRatio2 = 0.0;
11548 }
else if (
fstate == 4){
11550 dBrHXXRatio1 = BrHXXRatio - 1.0;
11551 dBrHXXRatio2 = 0.0;
11552 }
else if (
fstate == 5){
11554 dBrHXXRatio1 = BrHXXRatio - 1.0;
11555 dBrHXXRatio2 = 0.0;
11556 }
else if (
fstate == 6){
11558 dBrHXXRatio1 = BrHXXRatio - 1.0;
11559 dBrHXXRatio2 = 0.0;
11560 }
else if (
fstate == 7){
11562 dBrHXXRatio1 = BrHXXRatio - 1.0;
11563 dBrHXXRatio2 = 0.0;
11565 throw std::runtime_error(
"STXS12_qqHll_pTV250_400 called with invalid argument for final state in fstate_i");
11569 if ((this->
getModel()).isModelLinearized()){
11570 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11571 }
else if((this->
getModel()).isModelNPquadratic()){
11572 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11574 return weight*(muProd)*(BrHXXRatio);
11583:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11586 throw std::runtime_error(
"STXS12_qqHll_pTV400_Inf called with a class whose parent is not NPbase");
11593 double weight = 1.0;
11595 double muProd1 = muProd -1.0;
11596 double muProd2 = 0.0;
11599 double BrHXXRatio = 1.0;
11600 double dBrHXXRatio1 = 0.0;
11601 double dBrHXXRatio2 = 0.0;
11605 }
else if (
fstate == 1){
11607 dBrHXXRatio1 = BrHXXRatio - 1.0;
11608 dBrHXXRatio2 = 0.0;
11609 }
else if (
fstate == 2){
11611 dBrHXXRatio1 = BrHXXRatio - 1.0;
11612 dBrHXXRatio2 = 0.0;
11613 }
else if (
fstate == 3){
11615 dBrHXXRatio1 = BrHXXRatio - 1.0;
11616 dBrHXXRatio2 = 0.0;
11617 }
else if (
fstate == 4){
11619 dBrHXXRatio1 = BrHXXRatio - 1.0;
11620 dBrHXXRatio2 = 0.0;
11621 }
else if (
fstate == 5){
11623 dBrHXXRatio1 = BrHXXRatio - 1.0;
11624 dBrHXXRatio2 = 0.0;
11625 }
else if (
fstate == 6){
11627 dBrHXXRatio1 = BrHXXRatio - 1.0;
11628 dBrHXXRatio2 = 0.0;
11629 }
else if (
fstate == 7){
11631 dBrHXXRatio1 = BrHXXRatio - 1.0;
11632 dBrHXXRatio2 = 0.0;
11634 throw std::runtime_error(
"STXS12_qqHll_pTV400_Inf called with invalid argument for final state in fstate_i");
11638 if ((this->
getModel()).isModelLinearized()){
11639 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11640 }
else if((this->
getModel()).isModelNPquadratic()){
11641 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11643 return weight*(muProd)*(BrHXXRatio);
11653:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11656 throw std::runtime_error(
"STXS12_qqHll_pTV150_Inf called with a class whose parent is not NPbase");
11663 double weight = 1.0;
11670 double muProd1 = muProd-1.0;
11671 double muProd2 = 0.0;
11674 double BrHXXRatio = 1.0;
11675 double dBrHXXRatio1 = 0.0;
11676 double dBrHXXRatio2 = 0.0;
11678 weight = (0.0147+0.01683+0.00715+0.00126);
11679 }
else if (
fstate == 1){
11681 dBrHXXRatio1 = BrHXXRatio - 1.0;
11682 dBrHXXRatio2 = 0.0;
11683 }
else if (
fstate == 2){
11685 dBrHXXRatio1 = BrHXXRatio - 1.0;
11686 dBrHXXRatio2 = 0.0;
11687 }
else if (
fstate == 3){
11689 dBrHXXRatio1 = BrHXXRatio - 1.0;
11690 dBrHXXRatio2 = 0.0;
11691 }
else if (
fstate == 4){
11693 dBrHXXRatio1 = BrHXXRatio - 1.0;
11694 dBrHXXRatio2 = 0.0;
11695 }
else if (
fstate == 5){
11697 dBrHXXRatio1 = BrHXXRatio - 1.0;
11698 dBrHXXRatio2 = 0.0;
11699 }
else if (
fstate == 6){
11701 dBrHXXRatio1 = BrHXXRatio - 1.0;
11702 dBrHXXRatio2 = 0.0;
11703 }
else if (
fstate == 7){
11705 dBrHXXRatio1 = BrHXXRatio - 1.0;
11706 dBrHXXRatio2 = 0.0;
11708 throw std::runtime_error(
"STXS12_qqHll_pTV150_Inf called with invalid argument for final state in fstate_i");
11712 if ((this->
getModel()).isModelLinearized()){
11713 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11714 }
else if((this->
getModel()).isModelNPquadratic()){
11715 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11717 return weight*(muProd)*(BrHXXRatio);
11732:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11735 throw std::runtime_error(
"STXS12_qqHll called with a class whose parent is not NPbase");
11742 double weight = 1.0;
11750 )/(0.19845+0.0147+0.01683+0.00715+0.00126);
11751 double muProd1 = muProd - 1.0;
11752 double muProd2 = 0.0;
11755 double BrHXXRatio = 1.0;
11756 double dBrHXXRatio1 = 0.0;
11757 double dBrHXXRatio2 = 0.0;
11759 weight = (0.19845+0.0147+0.01683+0.00715+0.00126);
11760 }
else if (
fstate == 1){
11762 dBrHXXRatio1 = BrHXXRatio - 1.0;
11763 dBrHXXRatio2 = 0.0;
11764 }
else if (
fstate == 2){
11766 dBrHXXRatio1 = BrHXXRatio - 1.0;
11767 dBrHXXRatio2 = 0.0;
11768 }
else if (
fstate == 3){
11770 dBrHXXRatio1 = BrHXXRatio - 1.0;
11771 dBrHXXRatio2 = 0.0;
11772 }
else if (
fstate == 4){
11774 dBrHXXRatio1 = BrHXXRatio - 1.0;
11775 dBrHXXRatio2 = 0.0;
11776 }
else if (
fstate == 5){
11778 dBrHXXRatio1 = BrHXXRatio - 1.0;
11779 dBrHXXRatio2 = 0.0;
11780 }
else if (
fstate == 6){
11782 dBrHXXRatio1 = BrHXXRatio - 1.0;
11783 dBrHXXRatio2 = 0.0;
11784 }
else if (
fstate == 7){
11786 dBrHXXRatio1 = BrHXXRatio - 1.0;
11787 dBrHXXRatio2 = 0.0;
11789 throw std::runtime_error(
"STXS12_qqHll called with invalid argument for final state in fstate_i");
11793 if ((this->
getModel()).isModelLinearized()){
11794 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11795 }
else if((this->
getModel()).isModelNPquadratic()){
11796 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11798 return weight*(muProd)*(BrHXXRatio);
11811:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11814 throw std::runtime_error(
"STXS12_VHlep called with a class whose parent is not NPbase");
11821 double weight = 1.0;
11834 /(0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934
11835 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11837 double muProd1 = muProd - 1.0;
11838 double muProd2 = 0.0;
11841 double BrHXXRatio = 1.0;
11842 double dBrHXXRatio1 = 0.0;
11843 double dBrHXXRatio2 = 0.0;
11845 weight = (0.71256 + 0.06739 + 0.03943 + 0.01127 + 0.00339 + 0.07934
11846 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
11847 }
else if (
fstate == 1){
11849 dBrHXXRatio1 = BrHXXRatio - 1.0;
11850 dBrHXXRatio2 = 0.0;
11851 }
else if (
fstate == 2){
11853 dBrHXXRatio1 = BrHXXRatio - 1.0;
11854 dBrHXXRatio2 = 0.0;
11855 }
else if (
fstate == 3){
11857 dBrHXXRatio1 = BrHXXRatio - 1.0;
11858 dBrHXXRatio2 = 0.0;
11859 }
else if (
fstate == 4){
11861 dBrHXXRatio1 = BrHXXRatio - 1.0;
11862 dBrHXXRatio2 = 0.0;
11863 }
else if (
fstate == 5){
11865 dBrHXXRatio1 = BrHXXRatio - 1.0;
11866 dBrHXXRatio2 = 0.0;
11867 }
else if (
fstate == 6){
11869 dBrHXXRatio1 = BrHXXRatio - 1.0;
11870 dBrHXXRatio2 = 0.0;
11871 }
else if (
fstate == 7){
11873 dBrHXXRatio1 = BrHXXRatio - 1.0;
11874 dBrHXXRatio2 = 0.0;
11876 throw std::runtime_error(
"STXS12_VHlep called with invalid argument for final state in fstate_i");
11880 if ((this->
getModel()).isModelLinearized()){
11881 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11882 }
else if((this->
getModel()).isModelNPquadratic()){
11883 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11885 return weight*(muProd)*(BrHXXRatio);
11900:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11903 throw std::runtime_error(
"STXS12_VHlep_pTV0_150 called with a class whose parent is not NPbase");
11910 double weight = 1.0;
11917 /(0.71256 + 0.06739 + 0.07934);
11918 double muProd1 = muProd - 1.0;
11919 double muProd2 = 0.0;
11922 double BrHXXRatio = 1.0;
11923 double dBrHXXRatio1 = 0.0;
11924 double dBrHXXRatio2 = 0.0;
11927 }
else if (
fstate == 1){
11929 dBrHXXRatio1 = BrHXXRatio - 1.0;
11930 dBrHXXRatio2 = 0.0;
11931 }
else if (
fstate == 2){
11933 dBrHXXRatio1 = BrHXXRatio - 1.0;
11934 dBrHXXRatio2 = 0.0;
11935 }
else if (
fstate == 3){
11937 dBrHXXRatio1 = BrHXXRatio - 1.0;
11938 dBrHXXRatio2 = 0.0;
11939 }
else if (
fstate == 4){
11941 dBrHXXRatio1 = BrHXXRatio - 1.0;
11942 dBrHXXRatio2 = 0.0;
11943 }
else if (
fstate == 5){
11945 dBrHXXRatio1 = BrHXXRatio - 1.0;
11946 dBrHXXRatio2 = 0.0;
11947 }
else if (
fstate == 6){
11949 dBrHXXRatio1 = BrHXXRatio - 1.0;
11950 dBrHXXRatio2 = 0.0;
11951 }
else if (
fstate == 7){
11953 dBrHXXRatio1 = BrHXXRatio - 1.0;
11954 dBrHXXRatio2 = 0.0;
11956 throw std::runtime_error(
"STXS12_VHlep_pTV0_150 called with invalid argument for final state in fstate_i");
11960 if ((this->
getModel()).isModelLinearized()){
11961 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
11962 }
else if((this->
getModel()).isModelNPquadratic()){
11963 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
11965 return weight*(muProd)*(BrHXXRatio);
11979:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
11982 throw std::runtime_error(
"STXS12_VHlep_pTV150_Inf called with a class whose parent is not NPbase");
11989 double weight = 1.0;
11999 /(0.03943 + 0.01127 + 0.00339 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
12000 double muProd1 = (muProd - 1.0);
12001 double muProd2 = 0.0;
12004 double BrHXXRatio = 1.0;
12005 double dBrHXXRatio1 = 0.0;
12006 double dBrHXXRatio2 = 0.0;
12008 weight = (0.03943 + 0.01127 + 0.00339 + 0.0147 + 0.01683 + 0.00746 + 0.00043);
12009 }
else if (
fstate == 1){
12011 dBrHXXRatio1 = BrHXXRatio - 1.0;
12012 dBrHXXRatio2 = 0.0;
12013 }
else if (
fstate == 2){
12015 dBrHXXRatio1 = BrHXXRatio - 1.0;
12016 dBrHXXRatio2 = 0.0;
12017 }
else if (
fstate == 3){
12019 dBrHXXRatio1 = BrHXXRatio - 1.0;
12020 dBrHXXRatio2 = 0.0;
12021 }
else if (
fstate == 4){
12023 dBrHXXRatio1 = BrHXXRatio - 1.0;
12024 dBrHXXRatio2 = 0.0;
12025 }
else if (
fstate == 5){
12027 dBrHXXRatio1 = BrHXXRatio - 1.0;
12028 dBrHXXRatio2 = 0.0;
12029 }
else if (
fstate == 6){
12031 dBrHXXRatio1 = BrHXXRatio - 1.0;
12032 dBrHXXRatio2 = 0.0;
12033 }
else if (
fstate == 7){
12035 dBrHXXRatio1 = BrHXXRatio - 1.0;
12036 dBrHXXRatio2 = 0.0;
12038 throw std::runtime_error(
"STXS12_VHlep_pTV150_Inf called with invalid argument for final state in fstate_i");
12042 if ((this->
getModel()).isModelLinearized()){
12043 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12044 }
else if((this->
getModel()).isModelNPquadratic()){
12045 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12047 return weight*(muProd)*(BrHXXRatio);
12062:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12065 throw std::runtime_error(
"STXS12_ttH_pTH0_60 called with a class whose parent is not NPbase");
12072 double weight = 1.0;
12074 double muProd1 = muProd -1.0;
12075 double muProd2 = 0.0;
12078 double BrHXXRatio = 1.0;
12079 double dBrHXXRatio1 = 0.0;
12080 double dBrHXXRatio2 = 0.0;
12084 }
else if (
fstate == 1){
12086 dBrHXXRatio1 = BrHXXRatio - 1.0;
12087 dBrHXXRatio2 = 0.0;
12088 }
else if (
fstate == 2){
12090 dBrHXXRatio1 = BrHXXRatio - 1.0;
12091 dBrHXXRatio2 = 0.0;
12092 }
else if (
fstate == 3){
12094 dBrHXXRatio1 = BrHXXRatio - 1.0;
12095 dBrHXXRatio2 = 0.0;
12096 }
else if (
fstate == 4){
12098 dBrHXXRatio1 = BrHXXRatio - 1.0;
12099 dBrHXXRatio2 = 0.0;
12101 throw std::runtime_error(
"STXS12_ttH_pTH0_60 called with invalid argument for final state in fstate_i");
12105 if ((this->
getModel()).isModelLinearized()){
12106 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12107 }
else if((this->
getModel()).isModelNPquadratic()){
12108 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12110 return weight*(muProd)*(BrHXXRatio);
12120:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12123 throw std::runtime_error(
"STXS12_ttH_pTH60_120 called with a class whose parent is not NPbase");
12130 double weight = 1.0;
12132 double muProd1 = muProd -1.0;
12133 double muProd2 = 0.0;
12136 double BrHXXRatio = 1.0;
12137 double dBrHXXRatio1 = 0.0;
12138 double dBrHXXRatio2 = 0.0;
12142 }
else if (
fstate == 1){
12144 dBrHXXRatio1 = BrHXXRatio - 1.0;
12145 dBrHXXRatio2 = 0.0;
12146 }
else if (
fstate == 2){
12148 dBrHXXRatio1 = BrHXXRatio - 1.0;
12149 dBrHXXRatio2 = 0.0;
12150 }
else if (
fstate == 3){
12152 dBrHXXRatio1 = BrHXXRatio - 1.0;
12153 dBrHXXRatio2 = 0.0;
12154 }
else if (
fstate == 4){
12156 dBrHXXRatio1 = BrHXXRatio - 1.0;
12157 dBrHXXRatio2 = 0.0;
12159 throw std::runtime_error(
"STXS12_ttH_pTH60_120 called with invalid argument for final state in fstate_i");
12163 if ((this->
getModel()).isModelLinearized()){
12164 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12165 }
else if((this->
getModel()).isModelNPquadratic()){
12166 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12168 return weight*(muProd)*(BrHXXRatio);
12177:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12180 throw std::runtime_error(
"STXS12_ttH_pTH0_120 called with a class whose parent is not NPbase");
12187 double weight = 1.0;
12194 double muProd2 = 0.0;
12197 double BrHXXRatio = 1.0;
12198 double dBrHXXRatio1 = 0.0;
12199 double dBrHXXRatio2 = 0.0;
12203 }
else if (
fstate == 1){
12205 dBrHXXRatio1 = BrHXXRatio - 1.0;
12206 dBrHXXRatio2 = 0.0;
12207 }
else if (
fstate == 2){
12209 dBrHXXRatio1 = BrHXXRatio - 1.0;
12210 dBrHXXRatio2 = 0.0;
12211 }
else if (
fstate == 3){
12213 dBrHXXRatio1 = BrHXXRatio - 1.0;
12214 dBrHXXRatio2 = 0.0;
12215 }
else if (
fstate == 4){
12217 dBrHXXRatio1 = BrHXXRatio - 1.0;
12218 dBrHXXRatio2 = 0.0;
12220 throw std::runtime_error(
"STXS12_ttH_pTH0_120 called with invalid argument for final state in fstate_i");
12224 if ((this->
getModel()).isModelLinearized()){
12225 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12226 }
else if((this->
getModel()).isModelNPquadratic()){
12227 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12229 return weight*(muProd)*(BrHXXRatio);
12238:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12241 throw std::runtime_error(
"STXS12_ttH_pTH120_200 called with a class whose parent is not NPbase");
12248 double weight = 1.0;
12250 double muProd1 = muProd -1.0;
12251 double muProd2 = 0.0;
12254 double BrHXXRatio = 1.0;
12255 double dBrHXXRatio1 = 0.0;
12256 double dBrHXXRatio2 = 0.0;
12260 }
else if (
fstate == 1){
12262 dBrHXXRatio1 = BrHXXRatio - 1.0;
12263 dBrHXXRatio2 = 0.0;
12264 }
else if (
fstate == 2){
12266 dBrHXXRatio1 = BrHXXRatio - 1.0;
12267 dBrHXXRatio2 = 0.0;
12268 }
else if (
fstate == 3){
12270 dBrHXXRatio1 = BrHXXRatio - 1.0;
12271 dBrHXXRatio2 = 0.0;
12272 }
else if (
fstate == 4){
12274 dBrHXXRatio1 = BrHXXRatio - 1.0;
12275 dBrHXXRatio2 = 0.0;
12277 throw std::runtime_error(
"STXS12_ttH_pTH120_200 called with invalid argument for final state in fstate_i");
12281 if ((this->
getModel()).isModelLinearized()){
12282 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12283 }
else if((this->
getModel()).isModelNPquadratic()){
12284 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12286 return weight*(muProd)*(BrHXXRatio);
12295:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12298 throw std::runtime_error(
"STXS12_ttH_pTH200_300 called with a class whose parent is not NPbase");
12305 double weight = 1.0;
12307 double muProd1 = muProd -1.0;
12308 double muProd2 = 0.0;
12311 double BrHXXRatio = 1.0;
12312 double dBrHXXRatio1 = 0.0;
12313 double dBrHXXRatio2 = 0.0;
12317 }
else if (
fstate == 1){
12319 dBrHXXRatio1 = BrHXXRatio - 1.0;
12320 dBrHXXRatio2 = 0.0;
12321 }
else if (
fstate == 2){
12323 dBrHXXRatio1 = BrHXXRatio - 1.0;
12324 dBrHXXRatio2 = 0.0;
12325 }
else if (
fstate == 3){
12327 dBrHXXRatio1 = BrHXXRatio - 1.0;
12328 dBrHXXRatio2 = 0.0;
12329 }
else if (
fstate == 4){
12331 dBrHXXRatio1 = BrHXXRatio - 1.0;
12332 dBrHXXRatio2 = 0.0;
12334 throw std::runtime_error(
"STXS12_ttH_pTH200_300 called with invalid argument for final state in fstate_i");
12338 if ((this->
getModel()).isModelLinearized()){
12339 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12340 }
else if((this->
getModel()).isModelNPquadratic()){
12341 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12343 return weight*(muProd)*(BrHXXRatio);
12351:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12354 throw std::runtime_error(
"STXS12_ttH_pTH300_Inf called with a class whose parent is not NPbase");
12362 double weight = 1.0;
12366 )/(0.01903+0.00538);
12367 double muProd1 = muProd -1.0;
12368 double muProd2 = 0.0;
12371 double BrHXXRatio = 1.0;
12372 double dBrHXXRatio1 = 0.0;
12373 double dBrHXXRatio2 = 0.0;
12376 weight = (0.01903+0.00538);
12377 }
else if (
fstate == 1){
12379 dBrHXXRatio1 = BrHXXRatio - 1.0;
12380 dBrHXXRatio2 = 0.0;
12381 }
else if (
fstate == 2){
12383 dBrHXXRatio1 = BrHXXRatio - 1.0;
12384 dBrHXXRatio2 = 0.0;
12385 }
else if (
fstate == 3){
12387 dBrHXXRatio1 = BrHXXRatio - 1.0;
12388 dBrHXXRatio2 = 0.0;
12389 }
else if (
fstate == 4){
12391 dBrHXXRatio1 = BrHXXRatio - 1.0;
12392 dBrHXXRatio2 = 0.0;
12394 throw std::runtime_error(
"STXS12_ttH_pTH300_Inf called with invalid argument for final state in fstate_i");
12398 if ((this->
getModel()).isModelLinearized()){
12399 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12400 }
else if((this->
getModel()).isModelNPquadratic()){
12401 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12403 return weight*(muProd)*(BrHXXRatio);
12413:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12416 throw std::runtime_error(
"STXS12_ttH_pTH300_450 called with a class whose parent is not NPbase");
12423 double weight = 1.0;
12425 double muProd1 = muProd -1.0;
12426 double muProd2 = 0.0;
12429 double BrHXXRatio = 1.0;
12430 double dBrHXXRatio1 = 0.0;
12431 double dBrHXXRatio2 = 0.0;
12435 }
else if (
fstate == 1){
12437 dBrHXXRatio1 = BrHXXRatio - 1.0;
12438 dBrHXXRatio2 = 0.0;
12439 }
else if (
fstate == 2){
12441 dBrHXXRatio1 = BrHXXRatio - 1.0;
12442 dBrHXXRatio2 = 0.0;
12443 }
else if (
fstate == 3){
12445 dBrHXXRatio1 = BrHXXRatio - 1.0;
12446 dBrHXXRatio2 = 0.0;
12447 }
else if (
fstate == 4){
12449 dBrHXXRatio1 = BrHXXRatio - 1.0;
12450 dBrHXXRatio2 = 0.0;
12451 }
else if (
fstate == 5){
12453 dBrHXXRatio1 = BrHXXRatio - 1.0;
12454 dBrHXXRatio2 = 0.0;
12456 throw std::runtime_error(
"STXS12_ttH_pTH300_450 called with invalid argument for final state in fstate_i");
12460 if ((this->
getModel()).isModelLinearized()){
12461 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12462 }
else if((this->
getModel()).isModelNPquadratic()){
12463 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12465 return weight*(muProd)*(BrHXXRatio);
12473:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12476 throw std::runtime_error(
"STXS12_ttH_pTH450_Inf called with a class whose parent is not NPbase");
12483 double weight = 1.0;
12485 double muProd1 = muProd -1.0;
12486 double muProd2 = 0.0;
12489 double BrHXXRatio = 1.0;
12490 double dBrHXXRatio1 = 0.0;
12491 double dBrHXXRatio2 = 0.0;
12495 }
else if (
fstate == 1){
12497 dBrHXXRatio1 = BrHXXRatio - 1.0;
12498 dBrHXXRatio2 = 0.0;
12499 }
else if (
fstate == 2){
12501 dBrHXXRatio1 = BrHXXRatio - 1.0;
12502 dBrHXXRatio2 = 0.0;
12503 }
else if (
fstate == 3){
12505 dBrHXXRatio1 = BrHXXRatio - 1.0;
12506 dBrHXXRatio2 = 0.0;
12507 }
else if (
fstate == 4){
12509 dBrHXXRatio1 = BrHXXRatio - 1.0;
12510 dBrHXXRatio2 = 0.0;
12511 }
else if (
fstate == 5){
12513 dBrHXXRatio1 = BrHXXRatio - 1.0;
12514 dBrHXXRatio2 = 0.0;
12516 throw std::runtime_error(
"STXS12_ttH_pTH450_Inf called with invalid argument for final state in fstate_i");
12520 if ((this->
getModel()).isModelLinearized()){
12521 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12522 }
else if((this->
getModel()).isModelNPquadratic()){
12523 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12525 return weight*(muProd)*(BrHXXRatio);
12534:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12537 throw std::runtime_error(
"STXS12_ttH_pTH300_Inf_add called with a class whose parent is not NPbase");
12544 double weight = 1.0;
12549 double muProd1 = muProd - 1.0;
12550 double muProd2 = 0.0;
12553 double BrHXXRatio = 1.0;
12554 double dBrHXXRatio1 = 0.0;
12555 double dBrHXXRatio2 = 0.0;
12558 weight = (0.01903+0.00538);
12559 }
else if (
fstate == 1){
12561 dBrHXXRatio1 = BrHXXRatio - 1.0;
12562 dBrHXXRatio2 = 0.0;
12563 }
else if (
fstate == 2){
12565 dBrHXXRatio1 = BrHXXRatio - 1.0;
12566 dBrHXXRatio2 = 0.0;
12567 }
else if (
fstate == 3){
12569 dBrHXXRatio1 = BrHXXRatio - 1.0;
12570 dBrHXXRatio2 = 0.0;
12571 }
else if (
fstate == 4){
12573 dBrHXXRatio1 = BrHXXRatio - 1.0;
12574 dBrHXXRatio2 = 0.0;
12575 }
else if (
fstate == 5){
12577 dBrHXXRatio1 = BrHXXRatio - 1.0;
12578 dBrHXXRatio2 = 0.0;
12580 throw std::runtime_error(
"STXS12_ttH_pTH300_Inf_add called with invalid argument for final state in fstate_i");
12584 if ((this->
getModel()).isModelLinearized()){
12585 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12586 }
else if((this->
getModel()).isModelNPquadratic()){
12587 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12589 return weight*(muProd)*(BrHXXRatio);
12598:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12601 throw std::runtime_error(
"STXS12_ttH called with a class whose parent is not NPbase");
12608 double weight = 1.0;
12623 double muProd2 = 0.0;
12626 double BrHXXRatio = 1.0;
12627 double dBrHXXRatio1 = 0.0;
12628 double dBrHXXRatio2 = 0.0;
12630 weight = (0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 );
12631 }
else if (
fstate == 1){
12633 dBrHXXRatio1 = BrHXXRatio - 1.0;
12634 dBrHXXRatio2 = 0.0;
12635 }
else if (
fstate == 2){
12637 dBrHXXRatio1 = BrHXXRatio - 1.0;
12638 dBrHXXRatio2 = 0.0;
12639 }
else if (
fstate == 3){
12641 dBrHXXRatio1 = BrHXXRatio - 1.0;
12642 dBrHXXRatio2 = 0.0;
12643 }
else if (
fstate == 4){
12645 dBrHXXRatio1 = BrHXXRatio - 1.0;
12646 dBrHXXRatio2 = 0.0;
12647 }
else if (
fstate == 5){
12649 dBrHXXRatio1 = BrHXXRatio - 1.0;
12650 dBrHXXRatio2 = 0.0;
12651 }
else if (
fstate == 6){
12653 dBrHXXRatio1 = BrHXXRatio - 1.0;
12654 dBrHXXRatio2 = 0.0;
12655 }
else if (
fstate == 7){
12657 dBrHXXRatio1 = BrHXXRatio - 1.0;
12658 dBrHXXRatio2 = 0.0;
12660 throw std::runtime_error(
"STXS12_ttH called with invalid argument for final state in fstate_i");
12664 if ((this->
getModel()).isModelLinearized()){
12665 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12666 }
else if((this->
getModel()).isModelNPquadratic()){
12667 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12669 return weight*(muProd)*(BrHXXRatio);
12678:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12681 throw std::runtime_error(
"STXS12_tH called with a class whose parent is not NPbase");
12688 double weight = 1.0;
12690 double muProd1 = muProd -1.0;
12691 double muProd2 = 0.0;
12694 double BrHXXRatio = 1.0;
12695 double dBrHXXRatio1 = 0.0;
12696 double dBrHXXRatio2 = 0.0;
12700 }
else if (
fstate == 1){
12702 dBrHXXRatio1 = BrHXXRatio - 1.0;
12703 dBrHXXRatio2 = 0.0;
12704 }
else if (
fstate == 2){
12706 dBrHXXRatio1 = BrHXXRatio - 1.0;
12707 dBrHXXRatio2 = 0.0;
12708 }
else if (
fstate == 3){
12710 dBrHXXRatio1 = BrHXXRatio - 1.0;
12711 dBrHXXRatio2 = 0.0;
12712 }
else if (
fstate == 4){
12714 dBrHXXRatio1 = BrHXXRatio - 1.0;
12715 dBrHXXRatio2 = 0.0;
12716 }
else if (
fstate == 5){
12718 dBrHXXRatio1 = BrHXXRatio - 1.0;
12719 dBrHXXRatio2 = 0.0;
12720 }
else if (
fstate == 6){
12722 dBrHXXRatio1 = BrHXXRatio - 1.0;
12723 dBrHXXRatio2 = 0.0;
12724 }
else if (
fstate == 7){
12726 dBrHXXRatio1 = BrHXXRatio - 1.0;
12727 dBrHXXRatio2 = 0.0;
12729 throw std::runtime_error(
"STXS12_tH called with invalid argument for final state in fstate_i");
12733 if ((this->
getModel()).isModelLinearized()){
12734 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12735 }
else if((this->
getModel()).isModelNPquadratic()){
12736 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12738 return weight*(muProd)*(BrHXXRatio);
12752:
ThObservable(SM_i), sqrt_s(sqrt_s_i), fstate(fstate_i)
12755 throw std::runtime_error(
"STXS12_ttH_tH called with a class whose parent is not NPbase");
12762 double weight = 1.0;
12772 ) /(0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 + 0.08207);
12773 double muProd1 = ( muProd - 1.0 );
12774 double muProd2 = 0.0;
12777 double BrHXXRatio = 1.0;
12778 double dBrHXXRatio1 = 0.0;
12779 double dBrHXXRatio2 = 0.0;
12781 weight = (0.09779 + 0.13884 + 0.05439 + 0.05303 + 0.00498 + 0.00060 + 0.08207);
12782 }
else if (
fstate == 1){
12784 dBrHXXRatio1 = BrHXXRatio - 1.0;
12785 dBrHXXRatio2 = 0.0;
12786 }
else if (
fstate == 2){
12788 dBrHXXRatio1 = BrHXXRatio - 1.0;
12789 dBrHXXRatio2 = 0.0;
12790 }
else if (
fstate == 3){
12792 dBrHXXRatio1 = BrHXXRatio - 1.0;
12793 dBrHXXRatio2 = 0.0;
12794 }
else if (
fstate == 4){
12796 dBrHXXRatio1 = BrHXXRatio - 1.0;
12797 dBrHXXRatio2 = 0.0;
12798 }
else if (
fstate == 5){
12800 dBrHXXRatio1 = BrHXXRatio - 1.0;
12801 dBrHXXRatio2 = 0.0;
12802 }
else if (
fstate == 6){
12804 dBrHXXRatio1 = BrHXXRatio - 1.0;
12805 dBrHXXRatio2 = 0.0;
12806 }
else if (
fstate == 7){
12808 dBrHXXRatio1 = BrHXXRatio - 1.0;
12809 dBrHXXRatio2 = 0.0;
12811 throw std::runtime_error(
"STXS12_ttH called with invalid argument for final state in fstate_i");
12815 if ((this->
getModel()).isModelLinearized()){
12816 return weight*( 1.0 + (muProd1 + dBrHXXRatio1));
12817 }
else if((this->
getModel()).isModelNPquadratic()){
12818 return weight*( 1.0 + (muProd1 + dBrHXXRatio1) + (muProd2 + dBrHXXRatio2 + muProd1*dBrHXXRatio1) );
12820 return weight*(muProd)*(BrHXXRatio);
12837 throw std::runtime_error(
"muTHUggHgaga called with a class whose parent is not NPbase");
12850 throw std::runtime_error(
"muTHUVBFHgaga called with a class whose parent is not NPbase");
12862 throw std::runtime_error(
"muTHUZHgaga called with a class whose parent is not NPbase");
12874 throw std::runtime_error(
"muTHUWHgaga called with a class whose parent is not NPbase");
12886 throw std::runtime_error(
"muTHUVHgaga called with a class whose parent is not NPbase");
12898 throw std::runtime_error(
"muTHUttHgaga called with a class whose parent is not NPbase");
12910 throw std::runtime_error(
"muTHUggHZga called with a class whose parent is not NPbase");
12922 throw std::runtime_error(
"muTHUggHZgamumu called with a class whose parent is not NPbase");
12934 throw std::runtime_error(
"muTHUVBFHZga called with a class whose parent is not NPbase");
12947 throw std::runtime_error(
"muTHUZHZga called with a class whose parent is not NPbase");
12959 throw std::runtime_error(
"muTHUWHZga called with a class whose parent is not NPbase");
12971 throw std::runtime_error(
"muTHUVHZga called with a class whose parent is not NPbase");
12983 throw std::runtime_error(
"muTHUttHZga called with a class whose parent is not NPbase");
12995 throw std::runtime_error(
"muTHUggHZZ called with a class whose parent is not NPbase");
13007 throw std::runtime_error(
"muTHUVBFHZZ called with a class whose parent is not NPbase");
13019 throw std::runtime_error(
"muTHUZHZZ called with a class whose parent is not NPbase");
13031 throw std::runtime_error(
"muTHUWHZZ called with a class whose parent is not NPbase");
13043 throw std::runtime_error(
"muTHUVHZZ called with a class whose parent is not NPbase");
13055 throw std::runtime_error(
"muTHUttHZZ called with a class whose parent is not NPbase");
13067 throw std::runtime_error(
"muTHUggHZZ4l called with a class whose parent is not NPbase");
13079 throw std::runtime_error(
"muTHUggHZZ4mu called with a class whose parent is not NPbase");
13091 throw std::runtime_error(
"muTHUVBFHZZ4l called with a class whose parent is not NPbase");
13103 throw std::runtime_error(
"muTHUZHZZ4l called with a class whose parent is not NPbase");
13115 throw std::runtime_error(
"muTHUWHZZ4l called with a class whose parent is not NPbase");
13127 throw std::runtime_error(
"muTHUVHZZ4l called with a class whose parent is not NPbase");
13139 throw std::runtime_error(
"muTHUttHZZ4l called with a class whose parent is not NPbase");
13151 throw std::runtime_error(
"muTHUggHWW called with a class whose parent is not NPbase");
13163 throw std::runtime_error(
"muTHUVBFHWW called with a class whose parent is not NPbase");
13175 throw std::runtime_error(
"muTHUZHWW called with a class whose parent is not NPbase");
13187 throw std::runtime_error(
"muTHUWHWW called with a class whose parent is not NPbase");
13199 throw std::runtime_error(
"muTHUVHWW called with a class whose parent is not NPbase");
13211 throw std::runtime_error(
"muTHUttHWW called with a class whose parent is not NPbase");
13223 throw std::runtime_error(
"muTHUggHWW2l2v called with a class whose parent is not NPbase");
13235 throw std::runtime_error(
"muTHUVBFHWW2l2v called with a class whose parent is not NPbase");
13247 throw std::runtime_error(
"muTHUZHWW2l2v called with a class whose parent is not NPbase");
13259 throw std::runtime_error(
"muTHUWHWW2l2v called with a class whose parent is not NPbase");
13271 throw std::runtime_error(
"muTHUVHWW2l2v called with a class whose parent is not NPbase");
13283 throw std::runtime_error(
"muTHUttHWW2l2v called with a class whose parent is not NPbase");
13295 throw std::runtime_error(
"muTHUggHmumu called with a class whose parent is not NPbase");
13307 throw std::runtime_error(
"muTHUVBFHmumu called with a class whose parent is not NPbase");
13319 throw std::runtime_error(
"muTHUZHmumu called with a class whose parent is not NPbase");
13331 throw std::runtime_error(
"muTHUWHmumu called with a class whose parent is not NPbase");
13343 throw std::runtime_error(
"muTHUVHmumu called with a class whose parent is not NPbase");
13355 throw std::runtime_error(
"muTHUttHmumu called with a class whose parent is not NPbase");
13367 throw std::runtime_error(
"muTHUggHtautau called with a class whose parent is not NPbase");
13379 throw std::runtime_error(
"muTHUVBFHtautau called with a class whose parent is not NPbase");
13391 throw std::runtime_error(
"muTHUZHtautau called with a class whose parent is not NPbase");
13403 throw std::runtime_error(
"muTHUWHtautau called with a class whose parent is not NPbase");
13415 throw std::runtime_error(
"muTHUVHtautau called with a class whose parent is not NPbase");
13427 throw std::runtime_error(
"muTHUttHtautau called with a class whose parent is not NPbase");
13439 throw std::runtime_error(
"muTHUggHbb called with a class whose parent is not NPbase");
13451 throw std::runtime_error(
"muTHUVBFHbb called with a class whose parent is not NPbase");
13463 throw std::runtime_error(
"muTHUZHbb called with a class whose parent is not NPbase");
13475 throw std::runtime_error(
"muTHUWHbb called with a class whose parent is not NPbase");
13487 throw std::runtime_error(
"muTHUVHbb called with a class whose parent is not NPbase");
13499 throw std::runtime_error(
"muTHUttHbb called with a class whose parent is not NPbase");
13512 throw std::runtime_error(
"muTHUVBFBRinv called with a class whose parent is not NPbase");
13526 throw std::runtime_error(
"muTHUVBFHinv called with a class whose parent is not NPbase");
13541 throw std::runtime_error(
"muTHUVHBRinv called with a class whose parent is not NPbase");
13555 throw std::runtime_error(
"muTHUVHinv called with a class whose parent is not NPbase");
double computeThValue()
A method to compute the branching ratio of Higgs decays into exotics (invisible or not).
BrHexotic(const StandardModel &SM_i)
Constructor.
BrHinvisible(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles.
double computeThValue()
A method to compute the branching ratio of Higgs decays into invisible particles (only decays into ne...
BrHinvisibleNP(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2e2muRatio(const StandardModel &SM_i)
Constructor.
BrHto2e2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHto2l2v_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio Br Br in the current model and in the Standard Model.
BrHto2l2v_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto2l2vRatio(const StandardModel &SM_i)
Constructor.
BrHto2mu2vRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4eRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHto4l_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br with in the current model and in the Standard Model.
BrHto4lRatio(const StandardModel &SM_i)
Constructor.
BrHto4muRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoVVRatio(const StandardModel &SM_i)
Constructor.
BrHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZZRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZga_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoZga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgaeeRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgallRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoZgamumuRatio(const StandardModel &SM_i)
Constructor.
BrHtoZmumuga_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtoZmumuga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobb_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtobb_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoccRatio(const StandardModel &SM_i)
Constructor.
BrHtoevmuvRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogaga_over_2e2mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogaga_over_gg_Ratio(const StandardModel &SM_i)
Constructor.
BrHtogaga_over_mumu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtogagaRatio(const StandardModel &SM_i)
Constructor.
BrHtogg_over_bb_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtogg_over_cc_Ratio(const StandardModel &SM_i)
Constructor.
BrHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtoinvRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtoll_vvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolljjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtolv_lvorjjRatio(const StandardModel &SM_i)
Constructor.
BrHtolvjjRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br , in the current model and in the Standard Model.
BrHtomumu_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_4mu_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumu_over_gaga_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtotautau_over_4l_Ratio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br Br in the current model and in the Standard Model.
BrHtotautauRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the Br in the current model and in the Standard Model.
BrHtovisRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the Higgs width in the current model and in the Standard Model.
GammaHRatio(const StandardModel &SM_i)
Constructor.
GammaHtoWWRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoZZRatio(const StandardModel &SM_i)
Constructor.
GammaHtoZgaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtobbRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoccRatio(const StandardModel &SM_i)
Constructor.
GammaHtogagaRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtoggRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtomumuRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtossRatio(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
double computeThValue()
A method to compute the the ratio of the in the current model and in the Standard Model.
GammaHtotautauRatio(const StandardModel &SM_i)
Constructor.
The auxiliary base model class for other model classes.
virtual const double muggHbb(const double sqrt_s) const
virtual const double muVHWW2l2v(const double sqrt_s) const
virtual const double STXS12_ggH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_qqHll_pTV_0_150(const double sqrt_s) const
The STXS bin .
virtual const double cbminuscc() const
virtual const double muTHUZHmumu(const double sqrt_s) const
virtual const double STXS12_qqHlv_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double deltaGammaHtautauRatio1() const
virtual const double STXS12_qqHll_pTV0_150(const double sqrt_s) const
The STXS bin , .
virtual const double BrH4eRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double mueeHvv(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUttHWW(const double sqrt_s) const
virtual const double muTHUttHZga(const double sqrt_s) const
virtual const double BrH2evRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muTHUttHbb(const double sqrt_s) const
virtual const double STXS12_ggH_pTH450_650(const double sqrt_s) const
The STXS bin , .
virtual const double muggHZga(const double sqrt_s) const
virtual const double STXS_ggH_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
virtual const double cVpluscb() const
virtual const double deltaGammaHtautauRatio2() const
virtual const double STXS12_ggH_mjj0_350_pTH60_120_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muVH(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
virtual const double muttHptH_HWW(const double sqrt_s) const
virtual const double mueeWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS12_ggHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_ggH_pTH300_450(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_ggH1j_pTH_200(const double sqrt_s) const
The STXS bin .
virtual const double delta_mutH_2(const double sqrt_s) const
virtual const double muttH(const double sqrt_s) const
The ratio between the t-tbar-Higgs associated production cross-section in the current model and in t...
virtual const double muVBF(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in the current model and in...
virtual const double BrHZgaRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double STXS12_qqHqq_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double mummZH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double muepWBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS_ggH2j_pTH_200(const double sqrt_s) const
The STXS bin .
virtual const double mummttH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double GammaHccRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double muttHgagaZeeboost(const double sqrt_s) const
The ratio in the , channel channel in the current model and in the Standard Model.
virtual const double muttHZZ4l(const double sqrt_s) const
virtual const double muVHZga(const double sqrt_s) const
virtual const double muggHpbbH_Htautau(const double sqrt_s) const
virtual const double muTHUZHZZ(const double sqrt_s) const
virtual const double STXS_qqHll_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
virtual const double muZHmumu(const double sqrt_s) const
virtual const double STXS12_qqHlv_pTV75_150(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_BrHbbRatio() const
The STXS BR .
virtual const double ccminusctau() const
virtual const double muTHUttHZZ(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_qqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
virtual const double muVBFHmumu(const double sqrt_s) const
virtual const double STXS12_ttH_pTH0_60(const double sqrt_s) const
The STXS bin , .
virtual const double muggHZZ4l(const double sqrt_s) const
virtual const double delta_muZH_2(const double sqrt_s) const
virtual const double cgaplusct() const
virtual const double muTHUVBFBRinv(const double sqrt_s) const
virtual const double muTHUVBFHZga(const double sqrt_s) const
virtual const double deltaGammaHbbRatio2() const
virtual const double muWHpT250(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
virtual const double muttHWW2l2v(const double sqrt_s) const
virtual const double STXS_ggH1j_pTH_120_200(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_qqHll_pTV250_400(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHqq_VH_had_Nj2(const double sqrt_s) const
The STXS bin , VH-had Ref. 2402.05742.
virtual const double BrHVVRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muggHpttH(const double sqrt_s) const
The ratio between the sum of gluon-gluon fusion and t-tbar-Higgs associated production cross-section...
virtual const double STXS12_qqHqq_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUVHBRinv(const double sqrt_s) const
virtual const double delta_mutH_1(const double sqrt_s) const
virtual const double delta2sBRH3(const double C1prod, const double C1Hxx) const
Quadratic contribution from the Higgs self-couplings modifications to the signal strength for in the...
virtual const double muTHUZHgaga(const double sqrt_s) const
virtual const double muTHUggHZZ(const double sqrt_s) const
virtual const double muTHUVBFHZZ(const double sqrt_s) const
virtual const double STXS12_ggH_pTH200_300_Nj01(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_ggHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double muggHpttHptHpbbH_Hmumu(const double sqrt_s) const
virtual const double GammaHbbRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUggHWW2l2v(const double sqrt_s) const
virtual const double STXS_ggH2j_pTH_60_120(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muVBFHZZ(const double sqrt_s) const
virtual const double muTHUggHWW(const double sqrt_s) const
virtual const double cgplusct() const
virtual const double muttHtautau(const double sqrt_s) const
virtual const double STXS_ZHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
virtual const double muTHUggHZga(const double sqrt_s) const
virtual const double mueettH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double muTHUZHbb(const double sqrt_s) const
virtual const double STXS12_ggH_pTH650_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double muVBFHWW(const double sqrt_s) const
virtual const double muWHWW(const double sqrt_s) const
virtual const double STXS12_qqHlv_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double muVBFHZga(const double sqrt_s) const
virtual const double muVBFHWW2l2v(const double sqrt_s) const
virtual const double deltaGammaTotalRatio1() const
virtual const double mueeZHGen(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS12_ggH_pTH60_120_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_BrH4lRatio() const
The STXS BR , .
virtual const double STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_ZHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
virtual const double BrH2e2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double BrH2e2muRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double BrHbbRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muggHgaga(const double sqrt_s) const
virtual const double muVHcc(const double sqrt_s) const
virtual const double mueeZllHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS12_ggH_pTH650_Inf_Nj01(const double sqrt_s) const
The STXS bin , .
virtual const double muttHptH_Hgaga(const double sqrt_s) const
virtual const double STXS_qqHll_pTV_150_250(const double sqrt_s) const
The STXS bin .
virtual const double BrHZgallRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double deltaGammaHZgaRatio2() const
virtual const double STXS12_ggH_pTH300_450_Nj01(const double sqrt_s) const
The STXS bin , .
virtual const double deltaGammaHmumuRatio1() const
virtual const double STXS12_qqHlv_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHlv_pTV250_400(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_WHqqHqq_VBFtopo_j3(const double sqrt_s) const
The STXS bin .
virtual const double STXS_qqHll_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
virtual const double muTHUWHbb(const double sqrt_s) const
virtual const double STXS_ttHtH(const double sqrt_s) const
The STXS bin .
virtual const double muTHUVHZZ4l(const double sqrt_s) const
virtual const double muppHmumu(const double sqrt_s) const
virtual const double muTHUVHinv(const double sqrt_s) const
virtual const double BrHll_vvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double delta_muttH_2(const double sqrt_s) const
virtual const double muZHZga(const double sqrt_s) const
virtual const double deltaGammaHmumuRatio2() const
virtual const double STXS_ggH1j_pTH_0_60(const double sqrt_s) const
The STXS bin .
virtual const double C1eeZBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
virtual const double muZHWW2l2v(const double sqrt_s) const
virtual const double muttHWW(const double sqrt_s) const
virtual const double muVHZZ(const double sqrt_s) const
virtual const double STXS12_ttH_pTH200_300(const double sqrt_s) const
The STXS bin , .
virtual const double deltaGammaHZgaRatio1() const
virtual const double deltaGammaHWWRatio1() const
virtual const double muTHUVHgaga(const double sqrt_s) const
virtual const double STXS_qqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
virtual const double muggHpbbH_HZZ(const double sqrt_s) const
virtual const double GammaHggRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double delta_muggH_1(const double sqrt_s) const
virtual const double STXS_qqHll_pTV_250(const double sqrt_s) const
The STXS bin .
virtual const double muZH(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
virtual const double delta_muVBF_1(const double sqrt_s) const
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double deltaGammaHZZRatio1() const
virtual const double muTHUVHWW(const double sqrt_s) const
virtual const double STXS_ZHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
virtual const double GammaHZZRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double BrHZZRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double STXS_qqHqq_nonVHtopo(const double sqrt_s) const
The STXS bin .
virtual const double muWHZga(const double sqrt_s) const
virtual const double muTHUttHtautau(const double sqrt_s) const
virtual const double muVBFpVH_Hmumu(const double sqrt_s) const
virtual const double muttHptH_HZZ(const double sqrt_s) const
virtual const double muTHUVHWW2l2v(const double sqrt_s) const
virtual const double mueettHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double C1eeWBF(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
virtual const double mueeZH(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS12_ggH_pTH450_650_Nj01(const double sqrt_s) const
The STXS bin , .
virtual const double GammaHWWRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double BrHtoinvRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muTHUttHgaga(const double sqrt_s) const
virtual const double BrH2muvRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double STXS_ggH_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
virtual const double muggHmumu(const double sqrt_s) const
virtual const double mueeHvvPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double muggHWW2l2v(const double sqrt_s) const
virtual const double muttHptH_Htautau(const double sqrt_s) const
virtual const double muZHbb(const double sqrt_s) const
virtual const double deltaGammaTotalRatio2() const
virtual const double STXS12_ggHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_qqHlv_pTV_250(const double sqrt_s) const
The STXS bin .
virtual const double muWHWW2l2v(const double sqrt_s) const
virtual const double STXS12_ggHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_WHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
virtual const double STXS_ZHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
virtual const double muZHtautau(const double sqrt_s) const
virtual const double muTHUVBFHgaga(const double sqrt_s) const
virtual const double deltaGammaHgagaRatio2() const
virtual const double muTHUWHWW(const double sqrt_s) const
virtual const double deltaGammaHgagaRatio1() const
virtual const double mutHgaga(const double sqrt_s) const
virtual const double muTHUWHWW2l2v(const double sqrt_s) const
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double mueeZqqHPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS12_ggH_pTH10_200_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double BrHssRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double delta_muttH_1(const double sqrt_s) const
virtual const double muZHgaga(const double sqrt_s) const
virtual const double UpperLimitZgammaC(const double sqrt_s) const
virtual const double C1eettH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
virtual const double BrH4lRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double STXS_qqHqq_VHtopo(const double sqrt_s) const
The STXS bin .
virtual const double muWHgaga(const double sqrt_s) const
virtual const double STXS12_BrHevmuvRatio() const
The STXS BR .
virtual const double STXS_qqHlv_pTV_0_250(const double sqrt_s) const
The STXS bin .
virtual const double Br_H_inv() const
The branching ratio of the of the Higgs into invisible particles.
virtual const double STXS12_ttH_pTH300_450(const double sqrt_s) const
The STXS bin , .
virtual const double BrHggRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muVBFHZZ4l(const double sqrt_s) const
virtual const double mummH(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double mummHNWA(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model,...
virtual const double STXS_ggH2j_pTH_0_200(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_ggH_pTH200_300(const double sqrt_s) const
The STXS bin , .
virtual const double BrHgagaRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muVBFHbb(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj0_60_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double mueeZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS_ggH1j_pTH_60_120(const double sqrt_s) const
The STXS bin .
virtual const double UpperLimitZgammaA13(const double sqrt_s) const
virtual const double muTHUVBFHmumu(const double sqrt_s) const
virtual const double STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHll_pTV0_75(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUggHZZ4mu(const double sqrt_s) const
virtual const double computeGammaTotalRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double STXS12_ggH_mjj350_700_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double delta2sH3(const double C1) const
Quadratic contribution from the Higgs self-couplings modifications to the signal strength for an obse...
virtual const double muTHUWHtautau(const double sqrt_s) const
virtual const double muTHUVBFHZZ4l(const double sqrt_s) const
virtual const double muZHWW(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj60_120_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double C1eeZH(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
virtual const double cbminusctau() const
virtual const double BrHlvjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double muVBFpVH(const double sqrt_s) const
The ratio between the sum of VBF and WH+ZH associated production cross-section in the current model ...
virtual const double GammaHssRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double BrH2mu2vRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double mueeWBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double muTHUttHZZ4l(const double sqrt_s) const
virtual const double muWHZZ4l(const double sqrt_s) const
virtual const double UpperLimitZgammaC13(const double sqrt_s) const
virtual const double muTHUttHWW2l2v(const double sqrt_s) const
virtual const double STXS12_ggHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double mueeZBFPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS12_ggH_mjj0_350_pTH120_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double GammaHZgaRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double GammaHgagaRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double Br_H_exo() const
The branching ratio of the of the Higgs into exotic particles.
virtual const double muggHpbbH_Hgaga(const double sqrt_s) const
virtual const double muWHbb(const double sqrt_s) const
virtual const double muVHWW(const double sqrt_s) const
virtual const double muTHUVHZZ(const double sqrt_s) const
virtual const double muggHH(const double sqrt_s) const
The ratio between the gluon-gluon fusion di-Higgs production cross-section in the current model and ...
virtual const double STXS_ggH2j_pTH_120_200(const double sqrt_s) const
The STXS bin .
virtual const double muttHZbbboost(const double sqrt_s) const
The ratio in the channel in the current model and in the Standard Model.
virtual const double STXS_qqHqq_VBFtopo_Rest(const double sqrt_s) const
The STXS bin .
virtual const double muTHUWHZZ4l(const double sqrt_s) const
virtual const double STXS_WHqqHqq_VH2j(const double sqrt_s) const
The STXS bin .
virtual const double deltaGammaHZZRatio2() const
virtual const double muWHtautau(const double sqrt_s) const
virtual const double muTHUggHtautau(const double sqrt_s) const
virtual const double GammaHmumuRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double STXS12_ggH_mjj0_350_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
double C1HZga
The C1 coefficient controlling the H^3 corrections to the Higgs partial width from the Higgs trilinea...
virtual const double BrHZgaeeRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double STXS_WHqqHqq_pTj1_200(const double sqrt_s) const
The STXS bin .
virtual const double BrHevmuvRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muTHUVBFHinv(const double sqrt_s) const
virtual const double muggHpVBFpbbH_Hbb(const double sqrt_s) const
virtual const double GammaHtautauRatio() const
The ratio of the in the current model and in the Standard Model.
virtual const double muTHUggHgaga(const double sqrt_s) const
virtual const double muVHbb(const double sqrt_s) const
virtual const double STXS12_qqHll_pTV400_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUggHZZ4l(const double sqrt_s) const
virtual const double muttHgaga(const double sqrt_s) const
virtual const double muTHUggHbb(const double sqrt_s) const
virtual const double muTHUWHgaga(const double sqrt_s) const
virtual const double muWHmumu(const double sqrt_s) const
virtual const double muZHZZ(const double sqrt_s) const
virtual const double muttHZZ(const double sqrt_s) const
virtual const double deltaGammaHbbRatio1() const
virtual const double muWH(const double sqrt_s) const
The ratio between the W-Higgs associated production cross-section in the current model and in the St...
virtual const double STXS12_tH(const double sqrt_s) const
The STXS bin .
virtual const double C1eeHvv(const double sqrt_s) const
The C1 value controlling linear corrections from the Higgs self-coupling to single-Higgs processes fo...
virtual const double muWHZZ(const double sqrt_s) const
virtual const double Br_H_inv_NP() const
The branching ratio of the of the Higgs into invisible particles (only invisible new particles).
virtual const double muggHtautau(const double sqrt_s) const
virtual const double muttHmumu(const double sqrt_s) const
virtual const double STXS12_ggH_pTH0_60_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double muggHZZ(const double sqrt_s) const
virtual const double BrHlljjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double muTHUVBFHWW(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muVBFpVH_HZga(const double sqrt_s) const
virtual const double STXS_qqHlv_pTV_150_250_0j(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_qqHll_pTV150_250_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double BrHvisRatio() const
The ratio of the Br in the current model and in the Standard Model.
double C1Hmumu
The C1 coefficient controlling the H^3 corrections to the Higgs partial width from the Higgs trilinea...
virtual const double STXS12_BrHgagaRatio() const
The STXS BR .
virtual const double BrHccRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muVBFHtautau(const double sqrt_s) const
virtual const double muTHUVHbb(const double sqrt_s) const
virtual const double bPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
virtual const double muVHpT250(const double sqrt_s) const
The ratio between the WH+ZH associated production cross-section in the current model and in the Stan...
virtual const double delta_muVBF_2(const double sqrt_s) const
virtual const double STXS_ggH0j(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_qqHqq_VH_veto_Nj01(const double sqrt_s) const
The STXS bin , VH-veto Ref. 2402.05742.
virtual const double STXS12_qqHll_pTV150_250_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double mutHq(const double sqrt_s) const
The ratio between the t-q-Higgs associated production cross-section in the current model and in the ...
virtual const double muTHUggHZgamumu(const double sqrt_s) const
virtual const double STXS_ggH2j_pTH_0_60(const double sqrt_s) const
The STXS bin .
virtual const double STXS12_ggH_pTH10_Inf_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double mummHvv(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS12_qqHlv_pTV0_75(const double sqrt_s) const
The STXS bin , .
virtual const double muVHtautau(const double sqrt_s) const
virtual const double muggHpttHptHpbbH_HZga(const double sqrt_s) const
virtual const double BrH2l2vRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double BrH4muRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muttHZga(const double sqrt_s) const
virtual const double muTHUZHtautau(const double sqrt_s) const
virtual const double BrHmumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muVBFHgaga(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj120_350_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double STXS12_ggH_pTH120_200_Nj1(const double sqrt_s) const
The STXS bin , .
virtual const double UpperLimitZgammaA(const double sqrt_s) const
virtual const double muTHUZHZga(const double sqrt_s) const
virtual const double BrHWWRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muTHUVBFHWW2l2v(const double sqrt_s) const
virtual const double BrHZgamumuRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double mueeZllH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double delta_muZH_1(const double sqrt_s) const
virtual const double muVHmumu(const double sqrt_s) const
virtual const double STXS_WHqqHqq_VBFtopo_j3v(const double sqrt_s) const
The STXS bin .
virtual const double muTHUVHmumu(const double sqrt_s) const
virtual const double cgminuscga() const
virtual const double STXS0_qqH(const double sqrt_s) const
The STXS0 bin .
virtual const double delta_muggH_2(const double sqrt_s) const
virtual const double muTHUWHZZ(const double sqrt_s) const
virtual const double STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUVHtautau(const double sqrt_s) const
virtual const double muZHpT250(const double sqrt_s) const
The ratio between the Z-Higgs associated production cross-section in the current model and in the St...
virtual const double muppHZga(const double sqrt_s) const
virtual const double STXS_qqHqq_pTj_200(const double sqrt_s) const
The STXS bin .
virtual const double STXS_qqHlv_pTV_0_150(const double sqrt_s) const
The STXS bin .
virtual const double muVBFgamma(const double sqrt_s) const
The ratio between the vector-boson fusion Higgs production cross-section in association with a hard ...
virtual const double muggHgagaInt(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section with subsequent decay into 2...
virtual const double BrHlv_lvorjjRatio() const
The ratio of the Br ( ) in the current model and in the Standard Model.
virtual const double muggH(const double sqrt_s) const
The ratio between the gluon-gluon fusion Higgs production cross-section in the current model and in ...
virtual const double deltaGammaHWWRatio2() const
virtual const double STXS12_ttH_pTH450_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double muggHWW(const double sqrt_s) const
virtual const double cVplusctau() const
virtual const double muTHUZHWW2l2v(const double sqrt_s) const
virtual const double STXS_ZHqqHqq_Rest(const double sqrt_s) const
The STXS bin .
virtual const double muepZBF(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double delta_muWH_1(const double sqrt_s) const
virtual const double muTHUVBFHtautau(const double sqrt_s) const
virtual const double muggHpbbH_HWW(const double sqrt_s) const
virtual const double STXS12_qqHll_pTV75_150(const double sqrt_s) const
The STXS bin , .
virtual const double delta_muWH_2(const double sqrt_s) const
virtual const double muttHbb(const double sqrt_s) const
virtual const double muVHZZ4l(const double sqrt_s) const
virtual const double muTHUWHZga(const double sqrt_s) const
virtual const double mutH(const double sqrt_s) const
The ratio between the t-Higgs associated production cross-section in the current model and in the St...
virtual const double STXS12_ttH_pTH60_120(const double sqrt_s) const
The STXS bin , .
virtual const double aPskPol(const double sqrt_s, const double Pol_em, const double Pol_ep) const
the angular parameter from (arXiv:1708.09079 [hep-ph]).
virtual const double muTHUVBFHbb(const double sqrt_s) const
virtual const double muTHUWHmumu(const double sqrt_s) const
virtual const double STXS12_qqHlv_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double mueeZqqH(const double sqrt_s) const
The ratio between the associated production cross-section in the current model and in the Standard ...
virtual const double STXS_qqHlv_pTV_150_250_1j(const double sqrt_s) const
The STXS bin .
virtual const double muTHUZHZZ4l(const double sqrt_s) const
virtual const double STXS12_qqHll_pTV250_Inf(const double sqrt_s) const
The STXS bin , .
virtual const double muttHptH_Hmumu(const double sqrt_s) const
virtual const double muVHgaga(const double sqrt_s) const
virtual const double muttHptH_Hbb(const double sqrt_s) const
virtual const double muTHUttHmumu(const double sqrt_s) const
virtual const double STXS12_ttH_pTH120_200(const double sqrt_s) const
The STXS bin , .
virtual const double STXS_qqHqq_Rest(const double sqrt_s) const
The STXS bin .
virtual const double BrHtautauRatio() const
The ratio of the Br in the current model and in the Standard Model.
virtual const double muTHUggHmumu(const double sqrt_s) const
virtual const double muZHZZ4l(const double sqrt_s) const
virtual const double STXS12_ggH_pTH0_10_Nj0(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUZHWW(const double sqrt_s) const
virtual const double mummHmm(const double sqrt_s) const
The ratio between the production cross-section in the current model and in the Standard Model.
virtual const double STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const double sqrt_s) const
The STXS bin , .
virtual const double muTHUVHZga(const double sqrt_s) const
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_VHlep(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH0_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj0_350_pTH120_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj0_350_pTH60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_mjj350_700_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj350_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_mjj700_Inf_pTH0_200_ptHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_10_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH0_60_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_200_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH10_Inf_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH120_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH200_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_450_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH450_650_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_650(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggH_pTH60_120_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH60_200_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggH_pTH650_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ggHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ggHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHll_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHll(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV0_75(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_250_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV150_250_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV150_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_400(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV250_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHlv_pTV400_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHlv_pTV75_150(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj0(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_Nj1(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_VH_had_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_VH_veto_Nj01(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj0_60_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_1500_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj1000_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1000_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj120_350_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj1500_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_1000_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj350_700_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj350_Inf_pTH200_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj60_120_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_1000_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj0_25_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_qqHqq_mjj700_Inf_pTH0_200_pTHjj25_Inf_Nj2(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH0_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH0_60(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH120_200(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH200_300(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_450(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf_add(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH300_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_pTH450_Inf(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS12_ttH_pTH60_120(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH_tH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXS12_ttH(const StandardModel &SM_i, const double sqrt_s_i, unsigned int fstate_i)
Constructor.
STXS_0_qqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSWHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSWHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_Rest_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_VBFtopo_j3v_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSZHqqHqq_VH2j_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSZHqqHqq_pTj1_200_2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH0j4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH1j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_0_60_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_120_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH2j_pTH_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSggH2j_pTH_60_120_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSggH_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_150_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHll_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHll_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_150_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_0_150_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_0_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_0j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_0j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHlv_pTV_150_250_1j_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_150_250_1j_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHlv_pTV_250_bb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VBFtopo_Rest_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_VBFtopo_j3v_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSqqHqq_VHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_nonVHtopo_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
STXSqqHqq_pTj_200_4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
STXSttHtH4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of the STXS bin in the current model.
A model class for the Standard Model.
A class for a model prediction of an observable.
const StandardModel & getModel()
A get method to get the model.
const StandardModel & SM
A reference to an object of StandardMode class.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
UpperLimit_ppHZgammaC13(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
UpperLimit_ppHZgammaC(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute.
VBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
double computeThValue()
A method to compute the value of .
VBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
VBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
VBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
WHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
double computeThValue()
A method to compute the value of .
WHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
WHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
WHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
aPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
bPsk(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of the angular parameter from in the current model.
cV_plus_cb(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
cV_plus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
cb_minus_cc(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
cb_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cc_minus_ctau(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
cg_minus_cga(const StandardModel &SM_i)
Constructor.
cg_plus_ct(const StandardModel &SM_i)
Constructor.
double computeThValue()
A method to compute.
double computeThValue()
A method to compute.
cga_plus_ct(const StandardModel &SM_i)
Constructor.
ggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
double computeThValue()
A method to compute the value of .
ggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
ggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
muTHUVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muTHUVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muTHUVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muTHUVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muTHUttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFgamma(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_HZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVBFpVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVBFpVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHBRinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
muVH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVHinv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muVHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muVHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muWH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muWHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muWHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muZHpT250(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvWWPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvZZPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvZgaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvccPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeHvvgagaPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvggPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvmumuPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvss(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvssPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeHvvtautauPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueeWBFmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZBFbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHBRinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHGen(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZH(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHWW(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZHZZ(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZHZga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHbb(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZHcc(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZHgaga(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZHgg(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHinv(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZHmumu(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZHss(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZHtautau(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
mueeZllH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZllHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueeZqqH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueeZqqHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mueettH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueettHPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mueettHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mueettHbbPol(const StandardModel &SM_i, const double sqrt_s_i, const double Pol_em_i, const double Pol_ep_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
muepWBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepWBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
muepWBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepWBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBF(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
muepZBFgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muepZBFgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muepZBFtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHH2ga2b(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHZZ4mu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHZgamumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHgagaInt(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpVBFpbbH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpbbH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpbbH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpbbH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpbbH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muggHpttHptHpbbH_HZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHpttHptHpbbH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muggHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHWWNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHZZNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHZgaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHbbNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHccNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHgagaNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHggNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmm(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmmWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmmZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmmgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmmmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHmmtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHmumuNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHtautauNWA(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHvv(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHvvWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHvvZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHvvZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHvvbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHvvcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHvvgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummHvvgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummHvvmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummHvvtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummZHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummZHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummZHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummZHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummZHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummZHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummZHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummZHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mummttHcc(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHgg(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
double computeThValue()
A method to compute the value of in the current model.
mummttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mummttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muppHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muppHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
mutHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
mutHq(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttH(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the current model.
muttHVV(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHWW2l2v(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZZ4l(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHZbbboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHZga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHgagaZeeboost(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of in the channel in the current model.
muttHmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_HWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_HZZ(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Hbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Hgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Hmumu(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHptH_Htautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
muttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHWW(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
double computeThValue()
A method to compute the value of .
ttHbb(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
ttHgaga(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
double computeThValue()
A method to compute the value of .
double computeThValue()
A method to compute the value of .
ttHtautau(const StandardModel &SM_i, const double sqrt_s_i)
Constructor.
master
1.9.2